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

nautobot/__init__.py

@@ -14,18 +14,34 @@ __initialized = False
 
 def add_success_logger():
     """Add a custom log level for success messages."""
-    SUCCESS = 25
+    SUCCESS = 25  # between INFO and WARNING
     logging.addLevelName(SUCCESS, "SUCCESS")
 
-    def success(self, message, *args, **kws):
+    def success(self, message, *args, **kwargs):
+        kwargs["stacklevel"] = kwargs.get("stacklevel", 1) + 1  # so that funcName is the caller function, not "success"
         if self.isEnabledFor(SUCCESS):
-            self._log(SUCCESS, message, args, **kws)
+            self._log(SUCCESS, message, args, **kwargs)
 
     logging.Logger.success = success
     return success
 
 
+def add_failure_logger():
+    """Add a custom log level for failure messages less severe than an ERROR."""
+    FAILURE = 35  # between WARNING and ERROR
+    logging.addLevelName(FAILURE, "FAILURE")
+
+    def failure(self, message, *args, **kwargs):
+        kwargs["stacklevel"] = kwargs.get("stacklevel", 1) + 1  # so that funcName is the caller function, not "failure"
+        if self.isEnabledFor(FAILURE):
+            self._log(FAILURE, message, args, **kwargs)
+
+    logging.Logger.failure = failure
+    return failure
+
+
 add_success_logger()
+add_failure_logger()
 logger = logging.getLogger(__name__)
 
 

nautobot/core/celery/__init__.py

@@ -14,7 +14,7 @@ from django.utils.module_loading import import_string
 from kombu.serialization import register
 from prometheus_client import CollectorRegistry, multiprocess, start_http_server
 
-from nautobot import add_success_logger
+from nautobot import add_failure_logger, add_success_logger
 from nautobot.core.celery.control import discard_git_repository, refresh_git_repository  # noqa: F401  # unused-import
 from nautobot.core.celery.encoders import NautobotKombuJSONEncoder
 from nautobot.core.celery.log import NautobotDatabaseHandler
@@ -138,14 +138,16 @@ def add_nautobot_log_handler(logger_instance, log_format=None):
 
 @signals.after_setup_logger.connect
 def setup_nautobot_global_logging(logger, **kwargs):  # pylint: disable=redefined-outer-name
-    """Add SUCCESS log to celery global logger."""
+    """Add SUCCESS and FAILURE logs to celery global logger."""
     logger.success = add_success_logger()
+    logger.failure = add_failure_logger()
 
 
 @signals.after_setup_task_logger.connect
 def setup_nautobot_task_logging(logger, **kwargs):  # pylint: disable=redefined-outer-name
-    """Add SUCCESS log to celery task logger."""
+    """Add SUCCESS and FAILURE logs to celery task logger."""
     logger.success = add_success_logger()
+    logger.failure = add_failure_logger()
 
 
 @signals.celeryd_after_setup.connect

nautobot/core/jobs/__init__.py

@@ -295,8 +295,9 @@ class ImportObjects(Job):
                     validation_failed = True
             else:
                 validation_failed = True
-                for field, err in serializer.errors.items():
-                    self.logger.error("Row %d: `%s`: `%s`", row, field, err[0])
+                for field, errs in serializer.errors.items():
+                    for err in errs:
+                        self.logger.error("Row %d: `%s`: `%s`", row, field, err)
         return new_objs, validation_failed
 
     def run(self, *, content_type, csv_data=None, csv_file=None, roll_back_if_error=False):  # pylint:disable=arguments-differ

nautobot/core/testing/__init__.py

@@ -68,6 +68,8 @@ def run_job_for_testing(job, username="test-user", profile=False, **kwargs):
         username=username, defaults={"is_superuser": True, "password": "password"}
     )
     # Run the job synchronously in the current thread as if it were being executed by a worker
+    # TODO: in Nautobot core testing, we set `CELERY_TASK_ALWAYS_EAGER = True`, so we *could* use enqueue_job() instead,
+    #       but switching now would be a potentially breaking change for apps...
     job_result = JobResult.execute_job(
         job_model=job,
         user=user_instance,

nautobot/core/testing/mixins.py

@@ -18,6 +18,7 @@ from nautobot.core.models import fields as core_fields
 from nautobot.core.testing import utils
 from nautobot.core.utils import permissions
 from nautobot.extras import management, models as extras_models
+from nautobot.extras.choices import JobResultStatusChoices
 from nautobot.users import models as users_models
 
 # Use the proper swappable User model
@@ -188,6 +189,14 @@ class NautobotTestCaseMixin:
                 err_message = f"{msg}\n{err_message}"
         self.assertIn(response.status_code, expected_status, err_message)
 
+    def assertJobResultStatus(self, job_result, expected_status=JobResultStatusChoices.STATUS_SUCCESS):
+        """Assert that the given job_result has the expected_status, or print the job logs to aid in debugging."""
+        self.assertEqual(
+            job_result.status,
+            expected_status,
+            (job_result.traceback, list(job_result.job_log_entries.values_list("message", flat=True))),
+        )
+
     def assertInstanceEqual(self, instance, data, exclude=None, api=False):
         """
         Compare a model instance to a dictionary, checking that its attribute values match those specified

nautobot/core/tests/test_jobs.py

@@ -48,7 +48,7 @@ class ExportObjectListTest(TransactionTestCase):
             username=self.user.username,  # otherwise run_job_for_testing defaults to a superuser account
             content_type=ContentType.objects.get_for_model(Status).pk,
         )
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
         log_error = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
         self.assertEqual(log_error.message, f'User "{self.user}" does not have permission to view status objects')
         self.assertFalse(job_result.files.exists())
@@ -70,7 +70,7 @@ class ExportObjectListTest(TransactionTestCase):
             username=self.user.username,  # otherwise run_job_for_testing defaults to a superuser account
             content_type=ContentType.objects.get_for_model(Status).pk,
         )
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result)
         self.assertTrue(job_result.files.exists())
         self.assertEqual(Path(job_result.files.first().file.name).name, "nautobot_statuses.csv")
         csv_bytes = job_result.files.first().file.read()
@@ -86,7 +86,7 @@ class ExportObjectListTest(TransactionTestCase):
             "ExportObjectList",
             content_type=ContentType.objects.get_for_model(Status).pk,
         )
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result)
         self.assertTrue(job_result.files.exists())
         self.assertEqual(Path(job_result.files.first().file.name).name, "nautobot_statuses.csv")
         csv_data = job_result.files.first().file.read().decode("utf-8")
@@ -107,7 +107,7 @@ class ExportObjectListTest(TransactionTestCase):
             content_type=ContentType.objects.get_for_model(Status).pk,
             export_template=et.pk,
         )
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result)
         self.assertTrue(job_result.files.exists())
         self.assertEqual(Path(job_result.files.first().file.name).name, "nautobot_statuses.txt")
         text_data = job_result.files.first().file.read().decode("utf-8")
@@ -129,7 +129,7 @@ class ExportObjectListTest(TransactionTestCase):
             content_type=ContentType.objects.get_for_model(DeviceType).pk,
             export_format="yaml",
         )
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result)
         self.assertTrue(job_result.files.exists())
         self.assertEqual(Path(job_result.files.first().file.name).name, "nautobot_device_types.yaml")
         yaml_data = job_result.files.first().file.read().decode("utf-8")
@@ -159,7 +159,7 @@ class ImportObjectsTestCase(TransactionTestCase):
             content_type=ContentType.objects.get_for_model(Status).pk,
             csv_data=self.csv_data,
         )
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
         log_error = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
         self.assertEqual(log_error.message, f'User "{self.user}" does not have permission to create status objects')
         self.assertFalse(Status.objects.filter(name__startswith="test_status").exists())
@@ -172,7 +172,7 @@ class ImportObjectsTestCase(TransactionTestCase):
             username=self.user.username,  # otherwise run_job_for_testing defaults to a superuser account
             content_type=ContentType.objects.get_for_model(Status).pk,
         )
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
 
     def test_csv_import_with_constrained_permission(self):
         """Job should only allow the user to import objects they have permission to add."""
@@ -191,7 +191,7 @@ class ImportObjectsTestCase(TransactionTestCase):
             content_type=ContentType.objects.get_for_model(Status).pk,
             csv_data=self.csv_data,
         )
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
         log_successes = JobLogEntry.objects.filter(
             job_result=job_result, log_level=LogLevelChoices.LOG_INFO, message__icontains="created"
         )
@@ -220,7 +220,7 @@ class ImportObjectsTestCase(TransactionTestCase):
             content_type=ContentType.objects.get_for_model(Status).pk,
             csv_data=self.csv_data,
         )
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result)
         self.assertFalse(
             JobLogEntry.objects.filter(job_result=job_result, log_level=LogLevelChoices.LOG_WARNING).exists()
         )
@@ -246,7 +246,7 @@ class ImportObjectsTestCase(TransactionTestCase):
             content_type=ContentType.objects.get_for_model(Prefix).pk,
             csv_file=csv_file.id,
         )
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result)
         self.assertFalse(
             JobLogEntry.objects.filter(job_result=job_result, log_level=LogLevelChoices.LOG_WARNING).exists()
         )
@@ -287,7 +287,7 @@ class ImportObjectsTestCase(TransactionTestCase):
             content_type=ContentType.objects.get_for_model(Device).pk,
             csv_file=csv_file.id,
         )
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result)
         self.assertFalse(
             JobLogEntry.objects.filter(job_result=job_result, log_level=LogLevelChoices.LOG_WARNING).exists()
         )
@@ -313,7 +313,7 @@ class ImportObjectsTestCase(TransactionTestCase):
                 csv_data=csv_data,
                 roll_back_if_error=True,
             )
-            self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+            self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
             log_info = JobLogEntry.objects.filter(
                 job_result=job_result, log_level=LogLevelChoices.LOG_INFO, message__icontains="created"
             )
@@ -335,7 +335,7 @@ class ImportObjectsTestCase(TransactionTestCase):
                 content_type=ContentType.objects.get_for_model(Status).pk,
                 csv_data=csv_data,
             )
-            self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+            self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
             log_errors = JobLogEntry.objects.filter(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
             self.assertEqual(log_errors[0].message, "Row 1: `color`: `Enter a valid hexadecimal RGB color code.`")
             self.assertFalse(Status.objects.filter(name="test_status0").exists())
@@ -375,7 +375,7 @@ class ImportObjectsTestCase(TransactionTestCase):
             content_type=ContentType.objects.get_for_model(LocationType).pk,
             csv_data=location_types_csv,
         )
-        self.assertEqual(location_types_job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(location_types_job_result)
 
         location_type_count = LocationType.objects.filter(name="ContactAssignmentImportTestLocationType").count()
         self.assertEqual(location_type_count, 1, f"Unexpected count of LocationTypes {location_type_count}")
@@ -386,7 +386,7 @@ class ImportObjectsTestCase(TransactionTestCase):
             content_type=ContentType.objects.get_for_model(Location).pk,
             csv_data=locations_csv,
         )
-        self.assertEqual(locations_job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(locations_job_result)
 
         location_count = Location.objects.filter(location_type__name="ContactAssignmentImportTestLocationType").count()
         self.assertEqual(location_count, 2, f"Unexpected count of Locations {location_count}")
@@ -397,7 +397,7 @@ class ImportObjectsTestCase(TransactionTestCase):
             content_type=ContentType.objects.get_for_model(Contact).pk,
             csv_data=contacts_csv,
         )
-        self.assertEqual(contacts_job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(contacts_job_result)
 
         contact_count = Contact.objects.filter(name="Bob-ContactAssignmentImportTestLocation").count()
         self.assertEqual(contact_count, 1, f"Unexpected number of contacts {contact_count}")
@@ -408,7 +408,7 @@ class ImportObjectsTestCase(TransactionTestCase):
             content_type=ContentType.objects.get_for_model(Role).pk,
             csv_data=roles_csv,
         )
-        self.assertEqual(roles_job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(roles_job_result)
 
         role_count = Role.objects.filter(name="ContactAssignmentImportTestLocation-On Site").count()
         self.assertEqual(role_count, 1, f"Unexpected number of role values {role_count}")
@@ -426,8 +426,7 @@ class ImportObjectsTestCase(TransactionTestCase):
             content_type=ContentType.objects.get_for_model(ContactAssociation).pk,
             csv_data=associations_csv,
         )
-
-        self.assertEqual(associations_job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(associations_job_result)
 
 
 class LogsCleanupTestCase(TransactionTestCase):
@@ -469,7 +468,7 @@ class LogsCleanupTestCase(TransactionTestCase):
             cleanup_types=[CleanupTypes.JOB_RESULT],
             max_age=0,
         )
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
         log_error = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
         self.assertEqual(log_error.message, f'User "{self.user}" does not have permission to delete JobResult records')
         self.assertEqual(JobResult.objects.count(), job_result_count + 1)
@@ -484,7 +483,7 @@ class LogsCleanupTestCase(TransactionTestCase):
                 cleanup_types=[CleanupTypes.OBJECT_CHANGE],
                 max_age=0,
             )
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
         log_error = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
         self.assertEqual(
             log_error.message, f'User "{self.user}" does not have permission to delete ObjectChange records'
@@ -532,7 +531,7 @@ class LogsCleanupTestCase(TransactionTestCase):
             cleanup_types=[CleanupTypes.JOB_RESULT, CleanupTypes.OBJECT_CHANGE],
             max_age=0,
         )
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result)
         self.assertEqual(job_result.result["extras.JobResult"], 1)
         self.assertEqual(job_result.result["extras.ObjectChange"], 1)
         with self.assertRaises(JobResult.DoesNotExist):
@@ -629,7 +628,7 @@ class BulkEditTestCase(TransactionTestCase):
             tag.content_types.add(self.namespace_ct)
 
     def _common_no_error_test_assertion(self, model, job_result, expected_count, **filter_params):
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result)
         self.assertEqual(model.objects.filter(**filter_params).count(), expected_count)
         self.assertFalse(
             JobLogEntry.objects.filter(job_result=job_result, log_level=LogLevelChoices.LOG_WARNING).exists()
@@ -650,7 +649,7 @@ class BulkEditTestCase(TransactionTestCase):
             form_data={"pk": pk_list, "color": "aa1409"},
             username=self.user.username,
         )
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
         job_log = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
         self.assertEqual(job_log.message, f'User "{self.user}" does not have permission to update status objects')
 
@@ -961,7 +960,7 @@ class BulkDeleteTestCase(TransactionTestCase):
         )
 
     def _common_no_error_test_assertion(self, model, job_result, **filter_params):
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertJobResultStatus(job_result)
         self.assertEqual(model.objects.filter(**filter_params).count(), 0)
         self.assertFalse(
             JobLogEntry.objects.filter(job_result=job_result, log_level=LogLevelChoices.LOG_WARNING).exists()
@@ -979,7 +978,7 @@ class BulkDeleteTestCase(TransactionTestCase):
             pk_list=statuses_to_delete,
             username=self.user.username,
         )
-        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        self.assertJobResultStatus(job_result, JobResultStatusChoices.STATUS_FAILURE)
         job_log = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
         self.assertEqual(job_log.message, f'User "{self.user}" does not have permission to delete status objects')
         self.assertEqual(Status.objects.filter(pk__in=statuses_to_delete).count(), len(statuses_to_delete))
@@ -1002,7 +1001,7 @@ class BulkDeleteTestCase(TransactionTestCase):
             pk_list=statuses_to_delete,
             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.assertEqual(
             error_log.message, "You do not have permissions to delete some of the objects provided in `pk_list`."

nautobot/dcim/tests/test_jobs.py

@@ -71,7 +71,7 @@ def create_common_data_for_software_related_test_cases():
 class TestSoftwareImageFileTestCase(TransactionTestCase):
     def test_correct_handling_for_model_protected_error(self):
         create_common_data_for_software_related_test_cases()
-        software_image_file = SoftwareImageFile.objects.first()
+        software_image_file = SoftwareImageFile.objects.get(image_file_name="software_image_file_qs_test_1.bin")
 
         self.add_permissions("dcim.delete_softwareimagefile")
         pk_list = [str(software_image_file.pk)]
@@ -86,9 +86,7 @@ class TestSoftwareImageFileTestCase(TransactionTestCase):
             pk_list=pk_list,
             username=self.user.username,
         )
-        logs = JobLogEntry.objects.filter(job_result=job_result)
-        print([(log.message, log.log_level) for log in logs])
-        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("Caught ProtectedError while attempting to delete objects", error_log.message)
         self.assertEqual(initial_count, SoftwareImageFile.objects.all().count())
@@ -97,7 +95,7 @@ class TestSoftwareImageFileTestCase(TransactionTestCase):
 class TestSoftwareVersionTestCase(TransactionTestCase):
     def test_correct_handling_for_model_protected_error(self):
         create_common_data_for_software_related_test_cases()
-        software_version = SoftwareVersion.objects.first()
+        software_version = SoftwareVersion.objects.get(version="Test version 1.0.0")
 
         initial_count = SoftwareVersion.objects.all().count()
         self.add_permissions("dcim.delete_softwareversion")
@@ -112,7 +110,7 @@ class TestSoftwareVersionTestCase(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("Caught ProtectedError while attempting to delete objects", error_log.message)
         self.assertEqual(initial_count, SoftwareVersion.objects.all().count())

nautobot/extras/choices.py

@@ -251,8 +251,10 @@ class JobResultStatusChoices(ChoiceSet):
     """
 
     STATUS_FAILURE = states.FAILURE
+    STATUS_IGNORED = states.IGNORED
     STATUS_PENDING = states.PENDING
     STATUS_RECEIVED = states.RECEIVED
+    STATUS_REJECTED = states.REJECTED
     STATUS_RETRY = states.RETRY
     STATUS_REVOKED = states.REVOKED
     STATUS_STARTED = states.STARTED
@@ -302,27 +304,30 @@ class JobResultStatusChoices(ChoiceSet):
 class LogLevelChoices(ChoiceSet):
     LOG_DEBUG = "debug"
     LOG_INFO = "info"
+    LOG_SUCCESS = "success"
     LOG_WARNING = "warning"
+    LOG_FAILURE = "failure"
     LOG_ERROR = "error"
     LOG_CRITICAL = "critical"
-    LOG_SUCCESS = "success"
 
     CHOICES = (
         (LOG_DEBUG, "Debug"),
         (LOG_INFO, "Info"),
+        (LOG_SUCCESS, "Success"),
         (LOG_WARNING, "Warning"),
+        (LOG_FAILURE, "Failure"),
         (LOG_ERROR, "Error"),
         (LOG_CRITICAL, "Critical"),
-        (LOG_SUCCESS, "Success"),
     )
 
     CSS_CLASSES = {
         LOG_DEBUG: "debug",
         LOG_INFO: "info",
+        LOG_SUCCESS: "success",
         LOG_WARNING: "warning",
+        LOG_FAILURE: "failure",
         LOG_ERROR: "error",
         LOG_CRITICAL: "critical",
-        LOG_SUCCESS: "success",
     }