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

nautobot/extras/tests/git_helper.py

@@ -14,7 +14,7 @@ logger = logging.getLogger(__name__)
 SOURCE_DIR = os.path.join(os.path.dirname(__file__), "git_data")
 
 
-def create_and_populate_git_repository(target_path):
+def create_and_populate_git_repository(target_path, divergent_branch=None):
     """
     Create a Git repository in `target_path` and populate it with commits and tags based on contents of `SOURCE_DIR`.
 
@@ -40,6 +40,9 @@ def create_and_populate_git_repository(target_path):
     Note that each commit is fully defined by the files in the appropriate subdirectory; if you want a file to exist
     across multiple separate commits, it must exist in multiple subdirectories. Use of symlinks is encouraged in such
     a scenario.
+
+    You can optionally create and check out a divergent branch from the main branch by passing a branch name as the `divergent_branch`.
+    This will write a commit to the divergent branch and tag it with the branch name with the `-tag` suffix.
     """
     os.makedirs(target_path, exist_ok=True)
     repo = Repo.init(target_path, initial_branch="main")
@@ -69,6 +72,11 @@ def create_and_populate_git_repository(target_path):
         # Directory "01-valid-files" --> tag "valid-files" so that we won't break tests if we renumber the directories
         repo.create_tag(dirname[3:], message=f"Tag based on {dirname} files")
 
+    if divergent_branch:
+        repo.create_head(divergent_branch)
+        repo.index.commit("divergent-branch")
+        repo.create_tag(f"{divergent_branch}-tag", message=f"Tag for divergent branch {divergent_branch}")
+
 
 if __name__ == "__main__":
     directory_path = tempfile.TemporaryDirectory().name  # pylint: disable=consider-using-with

nautobot/extras/tests/integration/__init__.py

@@ -6,28 +6,41 @@ from nautobot.dcim.models import Device, DeviceType, Location, LocationType, Man
 from nautobot.extras.models import Role, Status
 
 
-def create_test_device():
-    test_uuid = str(uuid.uuid4())
-    device_role, _ = Role.objects.get_or_create(name="Device Role")
-    device_ct = ContentType.objects.get_for_model(Device)
-    device_role.content_types.add(device_ct)
-    manufacturer = Manufacturer.objects.create(
-        name=f"Test Manufacturer {test_uuid}",
-    )
-    device_type = DeviceType.objects.create(manufacturer=manufacturer, model=f"Test Model {test_uuid}")
-    location_type = LocationType.objects.create(name=f"Test Location Type {test_uuid}")
-    location_type.content_types.add(ContentType.objects.get_for_model(Device))
+def create_test_device(name=None, location_name=None, test_uuid=None):
+    if not test_uuid:
+        test_uuid = str(uuid.uuid4())
+    if not name:
+        name = f"Test Device {test_uuid}"
+    if not location_name:
+        location_name = f"Test Location {test_uuid}"
+
+    location_type, location_type_created = LocationType.objects.get_or_create(name=f"Test Location Type {test_uuid}")
+    if location_type_created:
+        location_type.content_types.add(ContentType.objects.get_for_model(Device))
+        location_type.save()
+
     location_status = Status.objects.get_for_model(Location).first()
-    location = Location.objects.create(
-        name=f"Test Location {test_uuid}",
+    location, _ = Location.objects.get_or_create(
+        name=location_name,
         status=location_status,
         location_type=location_type,
     )
-    device = Device.objects.create(
-        name=f"Test Device {test_uuid}",
+
+    device_role, device_role_created = Role.objects.get_or_create(name="Device Role")
+    if device_role_created:
+        device_role.content_types.add(ContentType.objects.get_for_model(Device))
+        device_role.save()
+
+    manufacturer, _ = Manufacturer.objects.get_or_create(
+        name=f"Test Manufacturer {test_uuid}",
+    )
+
+    device_type, _ = DeviceType.objects.get_or_create(manufacturer=manufacturer, model=f"Test Model {test_uuid}")
+
+    return Device.objects.create(
+        name=name,
         role=device_role,
         device_type=device_type,
         location=location,
         status=location_status,
     )
-    return device

nautobot/extras/tests/integration/test_plugin_banner.py

@@ -4,8 +4,6 @@ from nautobot.core.testing.integration import SeleniumTestCase
 class PluginBannerTestCase(SeleniumTestCase):
     """Integration test for rendering of plugin-injected banner content."""
 
-    fixtures = ("user-data",)
-
     def test_banner_not_rendered(self):
         """As implemented, plugin banner does not render if the user is not logged in.
 

nautobot/extras/tests/test_api.py

@@ -1207,6 +1207,10 @@ class GitRepositoryTest(APIViewTestCases.APIViewTestCase):
         url = reverse("extras-api:gitrepository-sync", kwargs={"pk": self.repos[0].id})
         response = self.client.post(url, format="json", **self.header)
         self.assertHttpStatus(response, status.HTTP_200_OK)
+        self.assertIn("message", response.data)
+        self.assertIn("job_result", response.data)
+        self.assertEqual(response.data["message"], f"Repository {self.repos[0].name} sync job added to queue.")
+        self.assertIsInstance(response.data["job_result"], dict)
 
     def test_create_with_app_provided_contents(self):
         """Test that `provided_contents` published by an App works."""
@@ -1241,6 +1245,8 @@ class GraphQLQueryTest(APIViewTestCases.APIViewTestCase):
         },
     ]
 
+    choices_fields = ["owner_content_type"]
+
     @classmethod
     def setUpTestData(cls):
         cls.graphqlqueries = (
@@ -1536,10 +1542,10 @@ class JobTest(
         self.assertHttpStatus(response, status.HTTP_404_NOT_FOUND)
 
         # Try post to permitted job
-        job_model = Job.objects.get_for_class_path("pass.TestPass")
+        job_model = Job.objects.get_for_class_path("pass.TestPassJob")
         job_model.enabled = True
         job_model.validated_save()
-        url = self.get_run_url("pass.TestPass")
+        url = self.get_run_url("pass.TestPassJob")
         response = self.client.post(url, **self.header)
         self.assertHttpStatus(response, self.run_success_response_status)
 
@@ -2129,7 +2135,7 @@ class JobTest(
     @mock.patch("nautobot.extras.api.views.get_worker_count", return_value=1)
     def test_run_job_with_default_queue_with_empty_job_model_job_queues(self, _):
         self.add_permissions("extras.run_job")
-        job_model = Job.objects.get_for_class_path("pass.TestPass")
+        job_model = Job.objects.get_for_class_path("pass.TestPassJob")
         data = {
             "task_queue": job_model.default_job_queue.name,
         }
@@ -2137,7 +2143,7 @@ class JobTest(
         job_model.job_queues.set([])
         job_model.enabled = True
         job_model.validated_save()
-        url = self.get_run_url("pass.TestPass")
+        url = self.get_run_url("pass.TestPassJob")
         response = self.client.post(url, data, format="json", **self.header)
         self.assertHttpStatus(response, self.run_success_response_status)
 
@@ -2564,10 +2570,10 @@ class ScheduledJobTest(
     @classmethod
     def setUpTestData(cls):
         user = User.objects.create(username="user1", is_active=True)
-        job_model = Job.objects.get_for_class_path("pass.TestPass")
+        job_model = Job.objects.get_for_class_path("pass.TestPassJob")
         ScheduledJob.objects.create(
             name="test1",
-            task="pass.TestPass",
+            task="pass.TestPassJob",
             job_model=job_model,
             interval=JobExecutionType.TYPE_IMMEDIATELY,
             user=user,
@@ -2576,7 +2582,7 @@ class ScheduledJobTest(
         )
         ScheduledJob.objects.create(
             name="test2",
-            task="pass.TestPass",
+            task="pass.TestPassJob",
             job_model=job_model,
             interval=JobExecutionType.TYPE_DAILY,
             user=user,
@@ -2586,7 +2592,7 @@ class ScheduledJobTest(
         )
         ScheduledJob.objects.create(
             name="test3",
-            task="pass.TestPass",
+            task="pass.TestPassJob",
             job_model=job_model,
             interval=JobExecutionType.TYPE_CUSTOM,
             crontab="34 12 * * *",
@@ -2601,12 +2607,12 @@ class JobApprovalTest(APITestCase):
     @classmethod
     def setUpTestData(cls):
         cls.additional_user = User.objects.create(username="user1", is_active=True)
-        cls.job_model = Job.objects.get_for_class_path("pass.TestPass")
+        cls.job_model = Job.objects.get_for_class_path("pass.TestPassJob")
         cls.job_model.enabled = True
         cls.job_model.save()
         cls.scheduled_job = ScheduledJob.objects.create(
             name="test pass",
-            task="pass.TestPass",
+            task="pass.TestPassJob",
             job_model=cls.job_model,
             interval=JobExecutionType.TYPE_IMMEDIATELY,
             user=cls.additional_user,
@@ -2659,7 +2665,7 @@ class JobApprovalTest(APITestCase):
         self.add_permissions("extras.approve_job", "extras.view_scheduledjob", "extras.change_scheduledjob")
         scheduled_job = ScheduledJob.objects.create(
             name="test",
-            task="pass.TestPass",
+            task="pass.TestPassJob",
             job_model=self.job_model,
             interval=JobExecutionType.TYPE_IMMEDIATELY,
             user=self.user,
@@ -2682,7 +2688,7 @@ class JobApprovalTest(APITestCase):
         self.add_permissions("extras.approve_job", "extras.view_scheduledjob", "extras.change_scheduledjob")
         scheduled_job = ScheduledJob.objects.create(
             name="test",
-            task="pass.TestPass",
+            task="pass.TestPassJob",
             job_model=self.job_model,
             interval=JobExecutionType.TYPE_FUTURE,
             one_off=True,
@@ -2699,7 +2705,7 @@ class JobApprovalTest(APITestCase):
         self.add_permissions("extras.approve_job", "extras.view_scheduledjob", "extras.change_scheduledjob")
         scheduled_job = ScheduledJob.objects.create(
             name="test",
-            task="pass.TestPass",
+            task="pass.TestPassJob",
             job_model=self.job_model,
             interval=JobExecutionType.TYPE_FUTURE,
             one_off=True,

nautobot/extras/tests/test_customfields.py

@@ -53,12 +53,12 @@ class CustomFieldTest(ModelTestCases.BaseModelTestCase, TestCase):
 
         instance.refresh_from_db()
         instance.key = "custom_field_2"
-        with self.assertRaises(ValidationError):
+        with self.assertRaisesRegex(ValidationError, "Key cannot be changed once created"):
             instance.validated_save()
 
         instance.refresh_from_db()
         instance.type = CustomFieldTypeChoices.TYPE_SELECT
-        with self.assertRaises(ValidationError):
+        with self.assertRaisesRegex(ValidationError, "Type cannot be changed once created"):
             instance.validated_save()
 
     def test_simple_fields(self):
@@ -165,9 +165,14 @@ class CustomFieldTest(ModelTestCases.BaseModelTestCase, TestCase):
         cf.save()
         cf.content_types.set([obj_type])
 
-        CustomFieldChoice.objects.create(custom_field=cf, value="Option A")
-        CustomFieldChoice.objects.create(custom_field=cf, value="Option B")
-        CustomFieldChoice.objects.create(custom_field=cf, value="Option C")
+        CustomFieldChoice.objects.create(custom_field=cf, value="Option A", weight=100)
+        self.assertEqual(["Option A"], cf.choices)
+        CustomFieldChoice.objects.create(custom_field=cf, value="Option B", weight=200)
+        self.assertEqual(["Option A", "Option B"], cf.choices)
+        CustomFieldChoice.objects.create(custom_field=cf, value="Option C", weight=300)
+        self.assertEqual(["Option A", "Option B", "Option C"], cf.choices)
+        with self.assertNumQueries(0):  # verify caching
+            self.assertEqual(["Option A", "Option B", "Option C"], cf.choices)
 
         # Assign a value to the first Location
         location = Location.objects.get(name="Location A")
@@ -199,9 +204,14 @@ class CustomFieldTest(ModelTestCases.BaseModelTestCase, TestCase):
         cf.save()
         cf.content_types.set([obj_type])
 
-        CustomFieldChoice.objects.create(custom_field=cf, value="Option A")
-        CustomFieldChoice.objects.create(custom_field=cf, value="Option B")
-        CustomFieldChoice.objects.create(custom_field=cf, value="Option C")
+        CustomFieldChoice.objects.create(custom_field=cf, value="Option A", weight=100)
+        self.assertEqual(["Option A"], cf.choices)
+        CustomFieldChoice.objects.create(custom_field=cf, value="Option B", weight=200)
+        self.assertEqual(["Option A", "Option B"], cf.choices)
+        CustomFieldChoice.objects.create(custom_field=cf, value="Option C", weight=300)
+        self.assertEqual(["Option A", "Option B", "Option C"], cf.choices)
+        with self.assertNumQueries(0):  # verify caching
+            self.assertEqual(["Option A", "Option B", "Option C"], cf.choices)
 
         # Assign a value to the first Location
         location = Location.objects.get(name="Location A")
@@ -293,21 +303,18 @@ class CustomFieldTest(ModelTestCases.BaseModelTestCase, TestCase):
         # Assign a disallowed value (list) to the first Location
         location = Location.objects.get(name="Location A")
         location.cf[cf.key] = ["I", "am", "a", "list"]
-        with self.assertRaises(ValidationError) as context:
+        with self.assertRaisesRegex(ValidationError, "Value must be a string"):
             location.validated_save()
-        self.assertIn("Value must be a string", str(context.exception))
 
         # Assign another disallowed value (int) to the first Location
         location.cf[cf.key] = 2
-        with self.assertRaises(ValidationError) as context:
+        with self.assertRaisesRegex(ValidationError, "Value must be a string"):
             location.validated_save()
-        self.assertIn("Value must be a string", str(context.exception))
 
         # Assign another disallowed value (bool) to the first Location
         location.cf[cf.key] = True
-        with self.assertRaises(ValidationError) as context:
+        with self.assertRaisesRegex(ValidationError, "Value must be a string"):
             location.validated_save()
-        self.assertIn("Value must be a string", str(context.exception))
 
         # Delete the stored value
         location.cf.pop(cf.key)
@@ -1294,7 +1301,7 @@ class CustomFieldModelTest(TestCase):
         custom_field.content_types.set([ContentType.objects.get_for_model(Provider)])
 
         provider = Provider.objects.create(name="Test")
-        with self.assertRaises(ValidationError):
+        with self.assertRaisesRegex(ValidationError, "Missing required custom field 'custom_field'"):
             provider.validated_save()
 
     def test_custom_field_required_on_update(self):
@@ -1312,7 +1319,7 @@ class CustomFieldModelTest(TestCase):
         provider = Provider.objects.create(name="Test", _custom_field_data={"custom_field": "Value"})
         provider.validated_save()
         provider._custom_field_data.pop("custom_field")
-        with self.assertRaises(ValidationError):
+        with self.assertRaisesRegex(ValidationError, "Missing required custom field 'custom_field'"):
             provider.validated_save()
 
     def test_update_removed_custom_field(self):
@@ -1373,7 +1380,7 @@ class CustomFieldModelTest(TestCase):
         """
         Check that a ValidationError is raised if any required custom fields are not present.
         """
-        cf3 = CustomField(type=CustomFieldTypeChoices.TYPE_TEXT, label="Baz", required=True)
+        cf3 = CustomField(key="baz", type=CustomFieldTypeChoices.TYPE_TEXT, label="Baz", required=True)
         cf3.save()
         cf3.content_types.set([ContentType.objects.get_for_model(Location)])
 
@@ -1381,7 +1388,7 @@ class CustomFieldModelTest(TestCase):
 
         # Set custom field data with a required field omitted
         location.cf["foo"] = "abc"
-        with self.assertRaises(ValidationError):
+        with self.assertRaisesRegex(ValidationError, "Missing required custom field 'baz'"):
             location.clean()
 
         location.cf["baz"] = "def"
@@ -1427,38 +1434,20 @@ class CustomFieldModelTest(TestCase):
         """
         Check the GraphQL validation method on CustomField Key Attribute.
         """
-        # Check if it catches the cf.key starting with a digit.
-        cf1 = CustomField(type=CustomFieldTypeChoices.TYPE_TEXT, label="Test 1", key="12_test_1")
-        with self.assertRaises(ValidationError) as error:
-            cf1.validated_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),
-        )
-        # Check if it catches the cf.key with whitespace.
-        cf1.key = "test 1"
-        with self.assertRaises(ValidationError) as error:
-            cf1.validated_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),
-        )
-        # Check if it catches the cf.key with hyphens.
-        cf1.key = "test-1-custom-field"
-        with self.assertRaises(ValidationError) as error:
-            cf1.validated_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),
-        )
-        # Check if it catches the cf.key with special characters
-        cf1.key = "test_1_custom_f)(&d"
-        with self.assertRaises(ValidationError) as error:
-            cf1.validated_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),
-        )
+        cf1 = CustomField(type=CustomFieldTypeChoices.TYPE_TEXT, label="Test 1")
+        for invalid_key in [
+            "12_test_1",  # Check if it catches the cf.key starting with a digit.
+            "test 1",  # Check if it catches the cf.key with whitespace.
+            "test-1-custom-field",  # Check if it catches the cf.key with hyphens.
+            "test_1_custom_f)(&d",  # Check if it catches the cf.key with special characters
+        ]:
+            with self.assertRaisesRegex(
+                ValidationError,
+                "This key is not Python/GraphQL safe. "
+                "Please do not start the key with a digit and do not use hyphens or whitespace",
+            ):
+                cf1.key = invalid_key
+                cf1.validated_save()
 
 
 class CustomFieldFilterTest(TestCase):
@@ -1934,9 +1923,11 @@ class CustomFieldChoiceTest(ModelTestCases.BaseModelTestCase):
         )
         self.cf.save()
         self.cf.content_types.set([obj_type])
+        self.assertEqual(self.cf.choices, [])
 
         self.choice = CustomFieldChoice(custom_field=self.cf, value="Foo")
         self.choice.save()
+        self.assertEqual(self.cf.choices, ["Foo"])
 
         location_status = Status.objects.get_for_model(Location).first()
         self.location_type = LocationType.objects.get(name="Campus")
@@ -1952,7 +1943,7 @@ class CustomFieldChoiceTest(ModelTestCases.BaseModelTestCase):
 
     def test_default_value_must_be_valid_choice_sad_path(self):
         self.cf.default = "invalid value"
-        with self.assertRaises(ValidationError):
+        with self.assertRaisesRegex(ValidationError, 'Invalid default value "invalid value"'):
             self.cf.full_clean()
 
     def test_default_value_must_be_valid_choice_happy_path(self):
@@ -1965,6 +1956,13 @@ class CustomFieldChoiceTest(ModelTestCases.BaseModelTestCase):
         with self.assertRaises(ProtectedError):
             self.choice.delete()
 
+    def test_inactive_choice_can_be_deleted(self):
+        self.location._custom_field_data.pop("cf1")
+        self.location.validated_save()
+        self.assertEqual(self.cf.choices, ["Foo"])
+        self.choice.delete()
+        self.assertEqual(self.cf.choices, [])
+
     def test_custom_choice_deleted_with_field(self):
         self.cf.delete()
         self.assertEqual(CustomField.objects.count(), 1)  # custom field automatically added by the Example App
@@ -2240,7 +2238,7 @@ class CustomFieldTableTest(TestCase):
             self.assertIsNotNone(custom_column, internal_col_name)
             self.assertIsInstance(custom_column, CustomFieldColumn)
 
-            rendered_value = bound_row.get_cell(internal_col_name)
+            rendered_value = bound_row.get_cell(internal_col_name)  # pylint: disable=no-member
             self.assertEqual(rendered_value, col_expected_value)
 
 

nautobot/extras/tests/test_datasources.py

@@ -30,6 +30,7 @@ from nautobot.extras.models import (
     ConfigContextSchema,
     ExportTemplate,
     GitRepository,
+    GraphQLQuery,
     Job,
     JobButton,
     JobHook,
@@ -197,6 +198,15 @@ class GitTest(TransactionTestCase):
         )
         self.assertIsNotNone(export_template_vlan)
 
+    def assert_graphql_query_exists(self, name="device_names.gql"):
+        """Helper function to assert Graphql query exists."""
+        graphql_query = GraphQLQuery.objects.get(
+            name=name,
+            owner_object_id=self.repo.pk,
+            owner_content_type=ContentType.objects.get_for_model(GitRepository),
+        )
+        self.assertIsNotNone(graphql_query)
+
     def assert_job_exists(self, name="MyJob", installed=True):
         """Helper function to assert JobModel and registered Job exist."""
         # Is it registered correctly in the database?
@@ -285,7 +295,8 @@ class GitTest(TransactionTestCase):
 
                 self.repo.secrets_group = secrets_group
                 self.repo.remote_url = "http://localhost/git.git"
-                self.repo.provided_contents.remove("extras.job")  # avoid failing due to lack of jobs module
+                # avoid failing due to lack of jobs module
+                self.repo.provided_contents.remove("extras.job")  # pylint: disable=no-member
                 self.repo.save()
 
                 self.mock_request.id = uuid.uuid4()
@@ -347,6 +358,10 @@ class GitTest(TransactionTestCase):
                 # Case when ContentType.model != ContentType.name, template was added and deleted during sync (#570)
                 self.assert_export_template_vlan_exists("template.j2")
 
+                # Make sure Graphgl queries were loaded
+                self.assert_graphql_query_exists("device_names")
+                self.assert_graphql_query_exists("device_interfaces")
+
                 # Make sure Jobs were successfully loaded from file and registered as JobModels
                 self.assert_job_exists(name="MyJob")
                 self.assert_job_exists(name="MyJobButtonReceiver")
@@ -438,6 +453,7 @@ class GitTest(TransactionTestCase):
                 self.assertFalse(ConfigContextSchema.objects.filter(owner_object_id=self.repo.id).exists())
                 self.assertFalse(ConfigContext.objects.filter(owner_object_id=self.repo.id).exists())
                 self.assertFalse(ExportTemplate.objects.filter(owner_object_id=self.repo.id).exists())
+                self.assertFalse(GraphQLQuery.objects.filter(owner_object_id=self.repo.id).exists())
                 self.assertFalse(Job.objects.filter(module_name__startswith=f"{self.repo.slug}.").exists())
                 device = Device.objects.get(name=self.device.name)
                 self.assertIsNone(device.local_config_context_data)
@@ -504,6 +520,11 @@ class GitTest(TransactionTestCase):
                         grouping="jobs",
                         message__contains="Error in loading Jobs from Git repository: ",
                     )
+                    failure_logs.get(
+                        grouping="graphql queries",
+                        message__contains="Error processing GraphQL query file 'bad_device_names.gql': Syntax Error GraphQL (4:5) Expected Name, found }",
+                    )
+
                 except (AssertionError, JobLogEntry.DoesNotExist):
                     for log in log_entries:
                         print(log.message)
@@ -629,6 +650,8 @@ class GitTest(TransactionTestCase):
                 self.assert_export_template_device("template.j2")
                 self.assert_export_template_html_exist("template2.html")
                 self.assert_export_template_vlan_exists("template.j2")
+                self.assert_graphql_query_exists(name="device_names")
+                self.assert_graphql_query_exists(name="device_interfaces")
                 self.assert_job_exists(name="MyJob")
                 self.assert_job_exists(name="MyJobButtonReceiver")
                 self.assert_job_exists(name="MyJobHookReceiver")
@@ -668,6 +691,8 @@ class GitTest(TransactionTestCase):
                     self.assert_export_template_device("template.j2")
                     self.assert_export_template_html_exist("template2.html")
                     self.assert_export_template_vlan_exists("template.j2")
+                    self.assert_graphql_query_exists("device_names")
+                    self.assert_graphql_query_exists("device_interfaces")
                     self.assert_job_exists(name="MyJob")
                     self.assert_job_exists(name="MyJobButtonReceiver")
                     self.assert_job_exists(name="MyJobHookReceiver")
@@ -710,6 +735,8 @@ class GitTest(TransactionTestCase):
                     log_entries.get(message__contains="Addition - `export_templates/dcim/device/template.j2`")
                     log_entries.get(message__contains="Addition - `export_templates/dcim/device/template2.html`")
                     log_entries.get(message__contains="Addition - `export_templates/ipam/vlan/template.j2`")
+                    log_entries.get(message__contains="Addition - `graphql_queries/device_interfaces.gql`")
+                    log_entries.get(message__contains="Addition - `graphql_queries/device_names.gql`")
                     log_entries.get(message__contains="Addition - `jobs/__init__.py`")
                     log_entries.get(message__contains="Addition - `jobs/my_job.py`")
                 except JobLogEntry.DoesNotExist:
@@ -720,6 +747,7 @@ class GitTest(TransactionTestCase):
                 self.assertFalse(ConfigContextSchema.objects.filter(owner_object_id=self.repo.pk).exists())
                 self.assertFalse(ConfigContext.objects.filter(owner_object_id=self.repo.pk).exists())
                 self.assertFalse(ExportTemplate.objects.filter(owner_object_id=self.repo.pk).exists())
+                self.assertFalse(GraphQLQuery.objects.filter(owner_object_id=self.repo.pk).exists())
                 self.assertFalse(Job.objects.filter(module_name__startswith=self.repo.slug).exists())
 
     # TODO: test dry-run against a branch name

nautobot/extras/tests/test_dynamicgroups.py

@@ -587,7 +587,7 @@ class DynamicGroupModelTest(DynamicGroupTestBase):  # TODO: BaseModelTestCase mi
         """
         pfx_content_type = ContentType.objects.get_for_model(Prefix)
         group = DynamicGroup(name="pfx", content_type=pfx_content_type)
-        filterset = group.filterset_class()
+        filterset = group.filterset_class()  # pylint: disable=not-callable  # should not be None here!
         fields = group._map_filter_fields
 
         # We know that `within_include` does not have a `generate_query_{filter_method}` method.

nautobot/extras/tests/test_filters.py

@@ -890,11 +890,11 @@ class JobFilterSetTestCase(FilterTestCases.FilterTestCase):
         Job.objects.last().tags.set(Tag.objects.get_for_model(Job)[:3])
 
     def test_installed(self):
-        params = {"job_class_name": "TestPass", "installed": True}
+        params = {"job_class_name": "TestPassJob", "installed": True}
         self.assertTrue(self.filterset(params, self.queryset).qs.exists())
 
     def test_enabled(self):
-        params = {"job_class_name": "TestPass", "enabled": False}
+        params = {"job_class_name": "TestPassJob", "enabled": False}
         self.assertTrue(self.filterset(params, self.queryset).qs.exists())
 
     def test_dryrun_default(self):
@@ -992,11 +992,11 @@ class JobResultFilterSetTestCase(FilterTestCases.FilterTestCase):
         jobs = Job.objects.all()[:3]
         cls.jobs = jobs
         user = User.objects.create(username="user1", is_active=True)
-        job_model = Job.objects.get_for_class_path("pass.TestPass")
+        job_model = Job.objects.get_for_class_path("pass.TestPassJob")
         scheduled_jobs = [
             ScheduledJob.objects.create(
                 name="test1",
-                task="pass.TestPass",
+                task="pass.TestPassJob",
                 job_model=job_model,
                 interval=JobExecutionType.TYPE_IMMEDIATELY,
                 user=user,
@@ -1005,7 +1005,7 @@ class JobResultFilterSetTestCase(FilterTestCases.FilterTestCase):
             ),
             ScheduledJob.objects.create(
                 name="test2",
-                task="pass.TestPass",
+                task="pass.TestPassJob",
                 job_model=job_model,
                 interval=JobExecutionType.TYPE_DAILY,
                 user=user,
@@ -1015,7 +1015,7 @@ class JobResultFilterSetTestCase(FilterTestCases.FilterTestCase):
             ),
             ScheduledJob.objects.create(
                 name="test3",
-                task="pass.TestPass",
+                task="pass.TestPassJob",
                 job_model=job_model,
                 interval=JobExecutionType.TYPE_CUSTOM,
                 crontab="34 12 * * *",

nautobot/extras/tests/test_forms.py

@@ -4,12 +4,13 @@ import warnings
 from django.contrib.auth import get_user_model
 from django.contrib.contenttypes.models import ContentType
 from django.db.models import Q
+from django.forms import ChoiceField, MultipleChoiceField
 from django.test import override_settings, TestCase
 
 from nautobot.dcim.forms import DeviceForm, LocationBulkEditForm, LocationForm
 import nautobot.dcim.models as dcim_models
 from nautobot.dcim.models import Device, Location, LocationType
-from nautobot.extras.choices import RelationshipTypeChoices
+from nautobot.extras.choices import CustomFieldTypeChoices, RelationshipTypeChoices
 from nautobot.extras.forms import (
     ConfigContextFilterForm,
     ConfigContextForm,
@@ -25,6 +26,7 @@ from nautobot.extras.forms import (
     WebhookForm,
 )
 from nautobot.extras.models import (
+    CustomField,
     Job,
     JobButton,
     JobHook,
@@ -908,6 +910,19 @@ class RelationshipModelBulkEditFormMixinTestCase(TestCase):
         ras = RelationshipAssociation.objects.filter(relationship=self.rel_mtom_s)
         self.assertEqual(1, ras.count())
 
+    def test_form_save_relationship_with_nullified_fields_is_none(self):
+        """Test save_relationships with nullified_fields=None."""
+        form = LocationBulkEditForm(
+            model=dcim_models.Location,
+            data={
+                "pks": [self.locations[0].pk],
+                "add_cr_multiplexing__destination": [ipaddress.pk for ipaddress in self.ipaddresses],
+                "add_cr_peer_locations__peer": [self.locations[1].pk],
+            },
+        )
+        form.is_valid()
+        form.save_relationships(instance=self.locations[0], nullified_fields=None)
+
     def test_location_form_remove_mtom(self):
         """Test removal of relationship-associations for many-to-many relationships."""
         RelationshipAssociation.objects.create(
@@ -1217,3 +1232,20 @@ class CustomFieldModelFormMixinTestCase(TestCase):
 
         custom_field_form = TestForm()
         self.assertIn("_custom_field_data", custom_field_form.fields)
+
+
+class CustomFieldTestCase(TestCase):
+    def test_to_form_field_type_select(self):
+        """Verify that `to_form_field` and `to_filter_form_field` return the correct field types for a select-type CustomField."""
+        custom_field = CustomField.objects.create(
+            type=CustomFieldTypeChoices.TYPE_SELECT,
+            label="Custom Field Select",
+        )
+        form = custom_field.to_filter_form_field()
+        self.assertIsInstance(form, MultipleChoiceField)
+
+        form = custom_field.to_form_field(for_filter_form=True)
+        self.assertIsInstance(form, MultipleChoiceField)
+
+        form = custom_field.to_form_field(for_filter_form=False)
+        self.assertIsInstance(form, ChoiceField)