nautobot 2.4.3__py3-none-any.whl → 2.4.5__py3-none-any.whl

nautobot/extras/tests/test_jobs.py

@@ -317,7 +317,7 @@ class JobTransactionTest(TransactionTestCase):
             pk_list=pk_list,
             username=self.user.username,
         )
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
         error_log = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
         self.assertIn(
             f"Unable to delete Job {system_job_queryset.first()}. System Job cannot be deleted", error_log.message
@@ -346,7 +346,7 @@ class JobTransactionTest(TransactionTestCase):
             },
             username=self.user.username,
         )
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result)
         self.assertEqual(Job.objects.filter(description=job_description).count(), queryset.count())
         self.assertFalse(
             JobLogEntry.objects.filter(job_result=job_result, log_level=LogLevelChoices.LOG_WARNING).exists()
@@ -389,7 +389,7 @@ class JobTransactionTest(TransactionTestCase):
             },
             username=self.user.username,
         )
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result)
         self.assertEqual(Job.objects.filter(description=job_description).count(), queryset.count())
         self.assertFalse(
             JobLogEntry.objects.filter(job_result=job_result, log_level=LogLevelChoices.LOG_WARNING).exists()
@@ -426,7 +426,7 @@ class JobTransactionTest(TransactionTestCase):
         module = "pass"
         name = "TestPassJob"
         job_result = create_job_result_and_run_job(module, name)
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result)
         self.assertEqual(job_result.result, True)
         logs = job_result.job_log_entries
         self.assertGreater(logs.count(), 0)
@@ -449,7 +449,7 @@ class JobTransactionTest(TransactionTestCase):
         name = "TestHasSensitiveVariables"
         # This function create_job_result_and_run_job and the subsequent functions' arguments are very messy
         job_result = create_job_result_and_run_job(module, name, "local", 1, 2, "3", kwarg_1=1, kwarg_2="2")
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result)
         self.assertEqual(job_result.task_args, [])
         self.assertEqual(job_result.task_kwargs, {})
 
@@ -458,21 +458,22 @@ class JobTransactionTest(TransactionTestCase):
         Job test with fail result.
         """
         module = "fail"
-        name = "TestFailJob"
-        job_result = create_job_result_and_run_job(module, name)
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
-        logs = job_result.job_log_entries
-        self.assertGreater(logs.count(), 0)
-        try:
-            logs.get(message="before_start() was called as expected")
-            logs.get(message="I'm a test job that fails!")
-            logs.get(message="on_failure() was called as expected")
-            logs.get(message="after_return() was called as expected")
-        except models.JobLogEntry.DoesNotExist:
-            for log in logs.all():
-                print(log.message)
-            print(job_result.traceback)
-            raise
+        for name in ["TestFailJob", "TestFailInBeforeStart", "TestFailCleanly", "TestFailCleanlyInBeforeStart"]:
+            with self.subTest(job=name):
+                job_result = create_job_result_and_run_job(module, name)
+                self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
+                logs = job_result.job_log_entries
+                self.assertGreater(logs.count(), 0)
+                try:
+                    logs.get(message="before_start() was called as expected")
+                    logs.get(message="I'm a test job that fails!")
+                    logs.get(message="on_failure() was called as expected")
+                    logs.get(message="after_return() was called as expected")
+                except models.JobLogEntry.DoesNotExist:
+                    for log in logs.all():
+                        print(log.message)
+                    print(job_result.traceback)
+                    raise
 
     def test_job_fail_with_sanitization(self):
         """
@@ -482,7 +483,7 @@ class JobTransactionTest(TransactionTestCase):
         name = "TestFailWithSanitization"
         job_result = create_job_result_and_run_job(module, name)
         json_result = json.dumps(job_result.result)
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
         self.assertIn("(redacted)@github.com", json_result)
         self.assertNotIn("abc123@github.com", json_result)
         self.assertIn("(redacted)@github.com", job_result.traceback)
@@ -495,7 +496,7 @@ class JobTransactionTest(TransactionTestCase):
         module = "atomic_transaction"
         name = "TestAtomicDecorator"
         job_result = create_job_result_and_run_job(module, name)
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result)
         # Ensure DB transaction was not aborted
         self.assertTrue(models.Status.objects.filter(name="Test database atomic rollback 1").exists())
         # Ensure the correct job log messages were saved
@@ -513,7 +514,7 @@ class JobTransactionTest(TransactionTestCase):
         module = "atomic_transaction"
         name = "TestAtomicContextManager"
         job_result = create_job_result_and_run_job(module, name)
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result)
         # Ensure DB transaction was not aborted
         self.assertTrue(models.Status.objects.filter(name="Test database atomic rollback 2").exists())
         # Ensure the correct job log messages were saved
@@ -530,8 +531,8 @@ class JobTransactionTest(TransactionTestCase):
         """
         module = "atomic_transaction"
         name = "TestAtomicDecorator"
-        job_result = create_job_result_and_run_job(module, name, fail=True)
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        job_result = create_job_result_and_run_job(module, name, should_fail=True)
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
         # Ensure DB transaction was aborted
         self.assertFalse(models.Status.objects.filter(name="Test database atomic rollback 1").exists())
         # Ensure the correct job log messages were saved
@@ -547,8 +548,8 @@ class JobTransactionTest(TransactionTestCase):
         """
         module = "atomic_transaction"
         name = "TestAtomicContextManager"
-        job_result = create_job_result_and_run_job(module, name, fail=True)
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        job_result = create_job_result_and_run_job(module, name, should_fail=True)
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
         # Ensure DB transaction was aborted
         self.assertFalse(models.Status.objects.filter(name="Test database atomic rollback 2").exists())
         # Ensure the correct job log messages were saved
@@ -596,7 +597,7 @@ class JobTransactionTest(TransactionTestCase):
         job_result_data = json.loads(log_info.log_object) if log_info.log_object else None
 
         # Assert stuff
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result)
         self.assertEqual(form_data, job_result_data)
 
     @override_settings(
@@ -651,7 +652,7 @@ class JobTransactionTest(TransactionTestCase):
         ).first()
 
         # Assert stuff
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result)
         self.assertEqual(info_log.log_object, "")
         self.assertEqual(info_log.message, f"Role: {role.name}")
         self.assertEqual(job_result.result, "Nice Roles!")
@@ -670,7 +671,7 @@ class JobTransactionTest(TransactionTestCase):
         ).first()
 
         # Assert stuff
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result)
         self.assertEqual(info_log.log_object, "")
         self.assertEqual(info_log.message, "The Location if any that the user provided.")
         self.assertEqual(job_result.result, "Nice Location (or not)!")
@@ -685,7 +686,7 @@ class JobTransactionTest(TransactionTestCase):
         job_result = create_job_result_and_run_job(module, name, **data)
 
         # Assert stuff
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
         self.assertIn("location is a required field", job_result.traceback)
 
     def test_job_latest_result_property(self):
@@ -695,9 +696,9 @@ class JobTransactionTest(TransactionTestCase):
         module = "pass"
         name = "TestPassJob"
         job_result_1 = create_job_result_and_run_job(module, name)
-        self.assertEqual(job_result_1.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result_1)
         job_result_2 = create_job_result_and_run_job(module, name)
-        self.assertEqual(job_result_2.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result_2)
         _job_class, job_model = get_job_class_and_model(module, name)
         self.assertGreaterEqual(job_model.job_results.count(), 2)
         latest_job_result = job_model.latest_result
@@ -710,11 +711,7 @@ class JobTransactionTest(TransactionTestCase):
         # The job itself contains the 'assert' by loading the resulting profiling file from the workers filesystem
         job_result = create_job_result_and_run_job(module, name, profile=True)
 
-        self.assertEqual(
-            job_result.status,
-            JobResultStatusChoices.STATUS_SUCCESS,
-            msg="Profiling test job errored, this indicates that either no profiling file was created or it is malformed.",
-        )
+        self.assertJobResultStatus(job_result)
 
         profiling_result = Path(f"{tempfile.gettempdir()}/nautobot-jobresult-{job_result.id}.pstats")
         self.assertTrue(profiling_result.exists())
@@ -727,12 +724,17 @@ class JobTransactionTest(TransactionTestCase):
         job_class, _ = get_job_class_and_model(module, name, "local")
         self.assertTrue(job_class.is_singleton)
         cache.set(job_class.singleton_cache_key, 1)
-        failed_job_result = create_job_result_and_run_job(module, name)
+        try:
+            failed_job_result = create_job_result_and_run_job(module, name)
 
-        self.assertEqual(
-            failed_job_result.status, JobResultStatusChoices.STATUS_FAILURE, msg="Duplicate singleton job didn't error."
-        )
-        self.assertIsNone(cache.get(job_class.singleton_cache_key, None))
+            self.assertEqual(
+                failed_job_result.status,
+                JobResultStatusChoices.STATUS_FAILURE,
+                msg="Duplicate singleton job didn't error.",
+            )
+        finally:
+            # Clean up after ourselves
+            cache.delete(job_class.singleton_cache_key)
 
     def test_job_ignore_singleton(self):
         module = "singleton"
@@ -741,16 +743,21 @@ class JobTransactionTest(TransactionTestCase):
         job_class, _ = get_job_class_and_model(module, name, "local")
         self.assertTrue(job_class.is_singleton)
         cache.set(job_class.singleton_cache_key, 1)
-        passed_job_result = create_job_result_and_run_job(
-            module, name, celery_kwargs={"nautobot_job_ignore_singleton_lock": True}
-        )
+        try:
+            passed_job_result = create_job_result_and_run_job(
+                module, name, celery_kwargs={"nautobot_job_ignore_singleton_lock": True}
+            )
 
-        self.assertEqual(
-            passed_job_result.status,
-            JobResultStatusChoices.STATUS_SUCCESS,
-            msg="Duplicate singleton job didn't succeed with nautobot_job_ignore_singleton_lock=True.",
-        )
-        self.assertIsNone(cache.get(job_class.singleton_cache_key, None))
+            self.assertEqual(
+                passed_job_result.status,
+                JobResultStatusChoices.STATUS_SUCCESS,
+                msg="Duplicate singleton job didn't succeed with nautobot_job_ignore_singleton_lock=True.",
+            )
+            # Singleton cache key should be cleared when the job completes
+            self.assertIsNone(cache.get(job_class.singleton_cache_key, None))
+        finally:
+            # Clean up after ourselves, just in case
+            cache.delete(job_class.singleton_cache_key)
 
     @mock.patch("nautobot.extras.context_managers.enqueue_webhooks")
     def test_job_fires_webhooks(self, mock_enqueue_webhooks):
@@ -762,7 +769,7 @@ class JobTransactionTest(TransactionTestCase):
         webhook.content_types.set([status_ct])
 
         job_result = create_job_result_and_run_job(module, name)
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result)
 
         mock_enqueue_webhooks.assert_called_once()
 
@@ -865,7 +872,7 @@ class JobFileOutputTest(TransactionTestCase):
         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)
+        self.assertJobResultStatus(job_result)
         # JobResult should have one attached file
         self.assertEqual(1, job_result.files.count())
         self.assertEqual(job_result.files.first().name, "output.txt")
@@ -896,7 +903,7 @@ class JobFileOutputTest(TransactionTestCase):
         # 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.assertJobResultStatus(job_result)
             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")
@@ -904,7 +911,7 @@ class JobFileOutputTest(TransactionTestCase):
         # 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.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
             self.assertIn("ValueError", job_result.traceback)
             self.assertEqual(0, job_result.files.count())
 
@@ -912,7 +919,7 @@ class JobFileOutputTest(TransactionTestCase):
         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.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
                 self.assertIn("ValueError", job_result.traceback)
                 self.assertEqual(0, job_result.files.count())
 
@@ -945,7 +952,7 @@ class RunJobManagementCommandTest(TransactionTestCase):
 
         out, err = self.run_command("--local", "--no-color", "--username", self.user.username, job_model.class_path)
         self.assertIn(f"Running {job_model.class_path}...", out)
-        self.assertIn("run: 0 debug, 1 info, 0 warning, 0 error, 0 critical", out)
+        self.assertIn("run: 0 debug, 1 info, 0 success, 0 warning, 0 failure, 0 error, 0 critical", out)
         self.assertIn("info: Success", out)
         self.assertIn(f"{job_model.class_path}: SUCCESS", out)
         self.assertEqual("", err)
@@ -967,7 +974,7 @@ class RunJobManagementCommandTest(TransactionTestCase):
         out, err = self.run_command("--local", "--no-color", "--username", self.user.username, job_model.class_path)
         self.assertIn(f"Running {job_model.class_path}...", out)
         # Changed job to actually log data. Can't display empty results if no logs were created.
-        self.assertIn("run: 0 debug, 1 info, 0 warning, 0 error, 0 critical", out)
+        self.assertIn("run: 0 debug, 1 info, 0 success, 0 warning, 0 failure, 0 error, 0 critical", out)
         self.assertIn(f"{job_model.class_path}: SUCCESS", out)
         self.assertEqual("", err)
 
@@ -999,7 +1006,7 @@ class JobLocationCustomFieldTest(TransactionTestCase):
         job_result = create_job_result_and_run_job(module, name)
         job_result.refresh_from_db()
 
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result)
 
         # Test location with a value for custom_field
         location_1 = Location.objects.filter(name="Test Location One")
@@ -1077,7 +1084,7 @@ class JobButtonReceiverTransactionTest(TransactionTestCase):
         module = "job_button_receiver"
         name = "TestJobButtonReceiverFail"
         job_result = create_job_result_and_run_job(module, name, **self.data)
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
 
 
 class JobHookReceiverTest(TestCase):
@@ -1149,7 +1156,7 @@ class JobHookReceiverTransactionTest(TransactionTestCase):
         module = "job_hook_receiver"
         name = "TestJobHookReceiverFail"
         job_result = create_job_result_and_run_job(module, name, **self.data)
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
 
 
 class JobHookTest(TestCase):

nautobot/extras/tests/test_models.py

@@ -1367,7 +1367,7 @@ class JobModelTest(ModelTestCases.BaseModelTestCase):
     def setUpTestData(cls):
         # JobModel instances are automatically instantiated at startup, so we just need to look them up.
         cls.local_job = JobModel.objects.get(job_class_name="TestPassJob")
-        cls.job_containing_sensitive_variables = JobModel.objects.get(job_class_name="ExampleLoggingJob")
+        cls.job_containing_sensitive_variables = JobModel.objects.get(job_class_name="TestHasSensitiveVariables")
         cls.app_job = JobModel.objects.get(job_class_name="ExampleJob")
 
     def test_job_class(self):

nautobot/extras/tests/test_plugins.py

@@ -17,11 +17,12 @@ from nautobot.dcim.models import Device, DeviceType, Location, LocationType, Man
 from nautobot.dcim.tests.test_views import create_test_device
 from nautobot.extras import plugins
 from nautobot.extras.choices import CustomFieldTypeChoices, RelationshipTypeChoices
+from nautobot.extras.context_managers import web_request_context
 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.plugins.validators import CustomValidator, wrap_model_clean_methods
 from nautobot.extras.plugins.views import extract_app_data
 from nautobot.extras.registry import DatasourceContent, registry
 from nautobot.ipam.models import IPAddress, Namespace, Prefix
@@ -478,6 +479,16 @@ class AppAPITest(APIViewTestCases.APIViewTestCase):
         pass
 
 
+class TestUserContextCustomValidator(CustomValidator):
+    model = "dcim.locationtype"
+
+    def clean(self):
+        """
+        Used to validate that the correct user context is available in the custom validator.
+        """
+        self.validation_error(self.context["user"])
+
+
 class AppCustomValidationTest(TestCase):
     def setUp(self):
         # When creating a fresh test DB, wrapping model clean methods fails, which is normal.
@@ -485,6 +496,7 @@ class AppCustomValidationTest(TestCase):
         # must manually call the method again to actually perform the action, now that the
         # ContentType table has been created.
         wrap_model_clean_methods()
+        super().setUp()
 
     def test_custom_validator_raises_exception(self):
         location_type = LocationType.objects.get(name="Campus")
@@ -513,6 +525,25 @@ class AppCustomValidationTest(TestCase):
         with self.assertRaises(ValidationError):
             relationship_assoc.clean()
 
+    def test_custom_validator_non_web_request_uses_anonymous_user(self):
+        location_type = LocationType.objects.get(name="Campus")
+        registry["plugin_custom_validators"]["dcim.locationtype"] = [TestUserContextCustomValidator]
+
+        from django.contrib.auth.models import AnonymousUser
+
+        with self.assertRaises(ValidationError) as context:
+            location_type.clean()
+        self.assertEqual(context.exception.message, AnonymousUser())
+
+    def test_custom_validator_web_request_uses_real_user(self):
+        location_type = LocationType.objects.get(name="Campus")
+        registry["plugin_custom_validators"]["dcim.locationtype"] = [TestUserContextCustomValidator]
+
+        with self.assertRaises(ValidationError) as context:
+            with web_request_context(user=self.user):
+                location_type.clean()
+        self.assertEqual(context.exception.message, self.user)
+
 
 class ExampleModelCustomActionViewTest(TestCase):
     """Test for custom action view `all_names` added to Example App"""

nautobot/extras/tests/test_relationships.py

@@ -1784,7 +1784,7 @@ class RelationshipJobTestCase(RequiredRelationshipTestMixin, TransactionTestCase
 
         pk_list = [str(vlan.id) for vlan in vlans]
         job_result = self.create_job(pk_list)
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
         error_log = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
         self.assertIn("VLANs require at least one device, but no devices exist yet.", error_log.message)
 
@@ -1793,7 +1793,7 @@ class RelationshipJobTestCase(RequiredRelationshipTestMixin, TransactionTestCase
 
         # Try editing all 6 VLANs without adding the required device(fails):
         job_result = self.create_job(pk_list)
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
         error_log = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
         self.assertIn(
             '6 VLANs require a device for the required relationship \\"VLANs require at least one Device',
@@ -1802,7 +1802,7 @@ class RelationshipJobTestCase(RequiredRelationshipTestMixin, TransactionTestCase
 
         # Try editing 3 VLANs without adding the required device(fails):
         job_result = self.create_job(pk_list[:3])
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
         error_log = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
         self.assertIn(
             'These VLANs require a device for the required relationship \\"VLANs require at least one Device',
@@ -1813,11 +1813,11 @@ class RelationshipJobTestCase(RequiredRelationshipTestMixin, TransactionTestCase
 
         # Try editing 6 VLANs and adding the required device (succeeds):
         job_result = self.create_job(pk_list, add_cr_vlans_devices_m2m__source=[str(device_for_association.id)])
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result)
 
         # Try editing 6 VLANs and removing the required device (fails):
         job_result = self.create_job(pk_list, remove_cr_vlans_devices_m2m__source=[str(device_for_association.id)])
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
         error_log = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
         self.assertIn(
             '6 VLANs require a device for the required relationship \\"VLANs require at least one Device',

nautobot/extras/tests/test_views.py

@@ -823,9 +823,12 @@ class DynamicGroupTestCase(
         location_ct = ContentType.objects.get_for_model(Location)
         instance = self._get_queryset().exclude(content_type=location_ct).first()
         # Add view permissions for the group's members:
-        self.add_permissions(get_permission_for_model(instance.content_type.model_class(), "view"))
+        self.add_permissions(
+            get_permission_for_model(instance.content_type.model_class(), "view"), "extras.view_dynamicgroup"
+        )
 
-        response = super().test_get_object_with_permission()
+        response = self.client.get(instance.get_absolute_url())
+        self.assertHttpStatus(response, 200)
 
         response_body = extract_page_body(response.content.decode(response.charset))
         # Check that the "members" table in the detail view includes all appropriate member objects
@@ -1177,6 +1180,13 @@ class GitRepositoryTestCase(
         self.form_data = form_data
         super().test_edit_object_with_constrained_permission()
 
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_view_when_no_sync_job_result_exists(self):
+        instance = self._get_queryset().first()
+        response = self.client.get(reverse("extras:gitrepository_result", kwargs={"pk": instance.pk}))
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.context["result"], {})
+
     def test_post_sync_repo_anonymous(self):
         self.client.logout()
         url = reverse("extras:gitrepository_sync", kwargs={"pk": self._get_queryset().first().pk})

nautobot/extras/views.py

@@ -1165,6 +1165,9 @@ class GitRepositoryResultView(generic.ObjectView):
     def get_extra_context(self, request, instance):
         job_result = instance.get_latest_sync()
 
+        if job_result is None:
+            job_result = {}
+
         return {
             "result": job_result,
             "base_template": "extras/gitrepository.html",
@@ -2059,7 +2062,13 @@ def get_annotated_jobresult_queryset():
             error_log_count=count_related(
                 JobLogEntry,
                 "job_result",
-                filter_dict={"log_level__in": [LogLevelChoices.LOG_ERROR, LogLevelChoices.LOG_CRITICAL]},
+                filter_dict={
+                    "log_level__in": [
+                        LogLevelChoices.LOG_FAILURE,
+                        LogLevelChoices.LOG_ERROR,
+                        LogLevelChoices.LOG_CRITICAL,
+                    ],
+                },
             ),
         )
     )

nautobot/ipam/api/serializers.py

@@ -63,14 +63,13 @@ class VRFDeviceAssignmentSerializer(ValidatedModelSerializer):
         validators = []
 
     def validate(self, attrs):
-        if attrs.get("device"):
-            validator = UniqueTogetherValidator(queryset=VRFDeviceAssignment.objects.all(), fields=("device", "vrf"))
-            validator(attrs, self)
-        if attrs.get("virtual_machine"):
-            validator = UniqueTogetherValidator(
-                queryset=VRFDeviceAssignment.objects.all(), fields=("virtual_machine", "vrf")
-            )
-            validator(attrs, self)
+        foreign_key_fields = ["device", "virtual_machine", "virtual_device_context"]
+        for foreign_key in foreign_key_fields:
+            if attrs.get(foreign_key):
+                validator = UniqueTogetherValidator(
+                    queryset=VRFDeviceAssignment.objects.all(), fields=(foreign_key, "vrf")
+                )
+                validator(attrs, self)
         return super().validate(attrs)
 
 

nautobot/ipam/api/views.py

@@ -55,13 +55,13 @@ class VRFViewSet(NautobotModelViewSet):
     filterset_class = filters.VRFFilterSet
 
 
-class VRFDeviceAssignmentViewSet(NautobotModelViewSet):
+class VRFDeviceAssignmentViewSet(ModelViewSet):
     queryset = VRFDeviceAssignment.objects.all()
     serializer_class = serializers.VRFDeviceAssignmentSerializer
     filterset_class = filters.VRFDeviceAssignmentFilterSet
 
 
-class VRFPrefixAssignmentViewSet(NautobotModelViewSet):
+class VRFPrefixAssignmentViewSet(ModelViewSet):
     queryset = VRFPrefixAssignment.objects.all()
     serializer_class = serializers.VRFPrefixAssignmentSerializer
     filterset_class = filters.VRFPrefixAssignmentFilterSet

nautobot/ipam/factory.py

@@ -15,7 +15,7 @@ from nautobot.core.factory import (
     random_instance,
     UniqueFaker,
 )
-from nautobot.dcim.models import Location
+from nautobot.dcim.models import Location, VirtualDeviceContext
 from nautobot.extras.models import Role, Status
 from nautobot.ipam.choices import PrefixTypeChoices
 from nautobot.ipam.models import IPAddress, Namespace, Prefix, RIR, RouteTarget, VLAN, VLANGroup, VRF
@@ -127,6 +127,24 @@ class VRFFactory(PrimaryModelFactory):
             else:
                 self.export_targets.set(get_random_instances(RouteTarget))
 
+    @factory.post_generation
+    def prefixes(self, create, extracted, **kwargs):
+        if create:
+            if extracted:
+                self.prefixes.set(extracted)
+            else:
+                self.prefixes.set(
+                    get_random_instances(lambda: Prefix.objects.filter(namespace=self.namespace), minimum=0)
+                )
+
+    @factory.post_generation
+    def virtual_device_contexts(self, create, extracted, **kwargs):
+        if create:
+            if extracted:
+                self.virtual_device_contexts.set(extracted)
+            else:
+                self.virtual_device_contexts.set(get_random_instances(VirtualDeviceContext))
+
 
 class VLANGroupFactory(OrganizationalModelFactory):
     class Meta:
@@ -295,7 +313,6 @@ class PrefixFactory(PrimaryModelFactory):
         has_role = NautobotBoolIterator()
         has_tenant = NautobotBoolIterator()
         has_vlan = NautobotBoolIterator()
-        # has_vrf = NautobotBoolIterator()
         is_ipv6 = NautobotBoolIterator()
 
     prefix = factory.Maybe(
@@ -321,12 +338,6 @@ class PrefixFactory(PrimaryModelFactory):
         None,
     )
     namespace = random_instance(Namespace, allow_null=False)
-    # TODO: Update for M2M tests
-    # vrf = factory.Maybe(
-    #     "has_vrf",
-    #     factory.SubFactory(VRFGetOrCreateFactory, tenant=factory.SelfAttribute("..tenant")),
-    #     None,
-    # )
     rir = factory.Maybe("has_rir", random_instance(RIR, allow_null=False), None)
     date_allocated = factory.Maybe("has_date_allocated", factory.Faker("date_time", tzinfo=datetime.timezone.utc), None)
 
@@ -343,6 +354,14 @@ class PrefixFactory(PrimaryModelFactory):
                     )
                 )
 
+    @factory.post_generation
+    def vrfs(self, create, extracted, **kwargs):
+        if create:
+            if extracted:
+                self.vrfs.set(extracted)
+            else:
+                self.vrfs.set(get_random_instances(lambda: VRF.objects.filter(namespace=self.namespace), minimum=0))
+
     @factory.post_generation
     def children(self, create, extracted, **kwargs):
         """Creates child prefixes and ip addresses within the prefix IP space.