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

nautobot/core/tests/test_events.py

@@ -0,0 +1,214 @@
+"""Test cases for the event notification APIs."""
+
+from collections import defaultdict
+import json
+
+from django.conf import settings
+import redis
+
+from nautobot.core.events import (
+    deregister_event_broker,
+    EventBroker,
+    load_event_brokers,
+    publish_event,
+    register_event_broker,
+)
+from nautobot.core.events.exceptions import EventBrokerImproperlyConfigured, EventBrokerNotFound
+from nautobot.core.testing import TestCase
+from nautobot.core.testing.context import load_event_broker_override_settings
+
+
+class TestEventBroker(EventBroker):
+    def __init__(self, **kwargs):
+        self.events = defaultdict(list)
+        super().__init__(**kwargs)
+
+    def publish(self, *, topic, payload):
+        self.events[topic].append(payload)
+
+
+class InvalidTestEventBroker:
+    """Broker that do not inherit from EventBroker"""
+
+    def __init__(self):
+        self.events = defaultdict(list)
+
+    def publish(self, *, topic, payload):
+        self.events[topic].append(payload)
+
+
+class EventNotificationTest(TestCase):
+    def test_publish_events_to_broker(self):
+        event_broker = TestEventBroker()
+        event_broker_2 = TestEventBroker()
+
+        # An event broker doesn't receive events if it isn't registered
+        publish_event(topic="nautobot.test.some_event", payload={"x": 0})
+        self.assertNotIn("nautobot.test.some_event", event_broker.events)
+        self.assertNotIn("nautobot.test.some_event", event_broker_2.events)
+
+        register_event_broker(event_broker)
+        # Events are not retroactively published by Nautobot
+        self.assertNotIn("nautobot.test.some_event", event_broker.events)
+        self.assertNotIn("nautobot.test.some_event", event_broker_2.events)
+
+        # Duplicate registration is a no-op
+        register_event_broker(event_broker)
+
+        # New events are published to the registered broker only
+        try:
+            publish_event(topic="nautobot.test.event", payload={"a": 1})
+            self.assertIn("nautobot.test.event", event_broker.events)
+            self.assertEqual(len(event_broker.events["nautobot.test.event"]), 1)
+            self.assertEqual(event_broker.events["nautobot.test.event"][0], json.dumps({"a": 1}))
+            self.assertNotIn("nautobot.test.event", event_broker_2.events)
+
+            # New events can be published to multiple brokers
+            register_event_broker(event_broker_2)
+            try:
+                publish_event(topic="nautobot.test.event", payload={"a": 2})
+                self.assertIn("nautobot.test.event", event_broker.events)
+                self.assertEqual(len(event_broker.events["nautobot.test.event"]), 2)
+                self.assertEqual(event_broker.events["nautobot.test.event"][1], json.dumps({"a": 2}))
+                self.assertIn("nautobot.test.event", event_broker_2.events)
+                self.assertEqual(len(event_broker_2.events["nautobot.test.event"]), 1)
+                self.assertEqual(event_broker_2.events["nautobot.test.event"][0], json.dumps({"a": 2}))
+            finally:
+                deregister_event_broker(event_broker_2)
+
+            # After deregistering one broker, it stops receiving events but the other remains registered and active
+            publish_event(topic="nautobot.test.another_event", payload={"b": 1})
+            self.assertIn("nautobot.test.another_event", event_broker.events)
+            self.assertEqual(len(event_broker.events["nautobot.test.another_event"]), 1)
+            self.assertEqual(event_broker.events["nautobot.test.another_event"][0], json.dumps({"b": 1}))
+            self.assertNotIn("nautobot.test.another_event", event_broker_2.events)
+
+        finally:
+            deregister_event_broker(event_broker)
+
+        # After deregistering both brokers, we can still publish events, but no one is listening
+        publish_event(topic="nautobot.test.yet_another_event", payload={"b": 2})
+        self.assertNotIn("nautobot.test.yet_another_event", event_broker.events)
+        self.assertNotIn("nautobot.test.yet_another_event", event_broker_2.events)
+
+        # Duplicate deregistration is a no-op
+        deregister_event_broker(event_broker)
+        deregister_event_broker(event_broker_2)
+
+    @load_event_broker_override_settings(
+        EVENT_BROKERS={
+            "SyslogEventBroker": {
+                "CLASS": "nautobot.core.events.SyslogEventBroker",
+                "TOPICS": {
+                    "INCLUDE": ["nautobot.test.*"],
+                    "EXCLUDE": ["*.no-publish*"],
+                },
+            }
+        }
+    )
+    def test_publish_events_to_syslog(self):
+        with self.assertLogs("nautobot.events.nautobot.test.event") as cm:
+            publish_event(topic="nautobot.test.event", payload={"a": 1})
+            publish_event(topic="nautobot.test.event.no-publish", payload={"a": 1})
+        # This test assets that only `nautobot.test.event` topic was published and `nautobot.test.event.no-publish` was not published
+        self.assertEqual(cm.output, ["INFO:nautobot.events.nautobot.test.event:" + json.dumps({"a": 1}, indent=4)])
+
+    @load_event_broker_override_settings(
+        EVENT_BROKERS={
+            "RedisEventBroker": {
+                "CLASS": "nautobot.core.events.RedisEventBroker",
+                "OPTIONS": {"url": settings.CACHES["default"]["LOCATION"]},
+                "TOPICS": {"EXCLUDE": ["*.test.event.no-publish"]},
+            }
+        }
+    )
+    def test_publish_events_to_redis(self):
+        url = settings.CACHES["default"]["LOCATION"]
+        connection = redis.StrictRedis.from_url(url, decode_responses=True)
+
+        sub = None
+        try:
+            connection = redis.StrictRedis.from_url(url, decode_responses=True)
+            sub = connection.pubsub()
+            sub.psubscribe("nautobot.*")
+            self.assertEqual(
+                sub.get_message(timeout=5.0),
+                {"type": "psubscribe", "pattern": None, "channel": "nautobot.*", "data": 1},
+            )
+            publish_event(topic="nautobot.test.event", payload={"b": 2})
+            self.assertEqual(
+                sub.get_message(timeout=5.0),
+                {"type": "pmessage", "pattern": "nautobot.*", "channel": "nautobot.test.event", "data": '{"b": 2}'},
+            )
+
+            # Assert exclude topics are not published
+            publish_event(topic="nautobot.test.event.no-publish", payload={"c": 3})
+            self.assertIsNone(sub.get_message(timeout=5.0))
+        finally:
+            if sub is not None:
+                sub.close()
+
+    def test_invalid_event_broker_config(self):
+        with self.assertRaises(EventBrokerNotFound) as err:
+            broker_config = {
+                "TestEventBroker": {
+                    "CLASS": "nautobot.core.tests.invalid_path.TestEventBroker",
+                }
+            }
+            load_event_brokers(broker_config)
+        self.assertEqual(
+            str(err.exception),
+            "Unable to import Event Broker TestEventBroker.",
+        )
+
+        with self.assertRaises(EventBrokerImproperlyConfigured) as err:
+            broker_config = {
+                "TestEventBroker": {
+                    "CLASS": "nautobot.core.tests.test_events.InvalidTestEventBroker",
+                }
+            }
+            load_event_brokers(broker_config)
+        self.assertEqual(
+            str(err.exception),
+            "TestEventBroker Malformed Event Broker Settings: Broker provided is not an EventBroker",
+        )
+
+        with self.assertRaises(EventBrokerImproperlyConfigured) as err:
+            broker_config = {
+                "TestEventBroker": {"CLASS": "nautobot.core.tests.test_events.TestEventBroker", "TOPICS": []}
+            }
+            load_event_brokers(broker_config)
+        self.assertEqual(
+            str(err.exception),
+            "TestEventBroker Malformed Event Broker Settings: Expected `TOPICS` to be a 'dict', instead a 'list' was provided",
+        )
+
+        with self.assertRaises(EventBrokerImproperlyConfigured) as err:
+            broker_config = {
+                "TestEventBroker": {
+                    "CLASS": "nautobot.core.tests.test_events.TestEventBroker",
+                    "TOPICS": {
+                        "INCLUDE": "nautobot.test.*",
+                    },
+                }
+            }
+            load_event_brokers(broker_config)
+        self.assertEqual(
+            str(err.exception),
+            "TestEventBroker Malformed Event Broker Settings: Expected `INCLUDE` to be a 'list' or 'tuple', instead a 'str' was provided",
+        )
+
+        with self.assertRaises(EventBrokerImproperlyConfigured) as err:
+            broker_config = {
+                "TestEventBroker": {
+                    "CLASS": "nautobot.core.tests.test_events.TestEventBroker",
+                    "TOPICS": {
+                        "EXCLUDE": "nautobot.test.*",
+                    },
+                }
+            }
+            load_event_brokers(broker_config)
+        self.assertEqual(
+            str(err.exception),
+            "TestEventBroker Malformed Event Broker Settings: Expected `EXCLUDE` to be a 'list' or 'tuple', instead a 'str' was provided",
+        )

nautobot/core/tests/test_jinja_filters.py

@@ -45,6 +45,7 @@ class NautobotJinjaFilterTest(TestCase):
             "get_item",
             "settings_or_config",
             "slugify",
+            "dbm",
         ]
 
         # For each helper, try to render jinja template with render_jinja2 and fail if TemplateAssertionError is raised

nautobot/core/tests/test_jobs.py

@@ -1,4 +1,5 @@
 from datetime import timedelta
+import json
 from pathlib import Path
 
 from django.contrib.contenttypes.models import ContentType
@@ -9,6 +10,7 @@ import yaml
 
 from nautobot.core.jobs.cleanup import CleanupTypes
 from nautobot.core.testing import create_job_result_and_run_job, TransactionTestCase
+from nautobot.core.testing.context import load_event_broker_override_settings
 from nautobot.dcim.models import Device, DeviceType, Location, LocationType, Manufacturer
 from nautobot.extras.choices import JobResultStatusChoices, LogLevelChoices
 from nautobot.extras.factory import JobResultFactory, ObjectChangeFactory
@@ -23,6 +25,7 @@ from nautobot.extras.models import (
     Role,
     Status,
 )
+from nautobot.extras.models.metadata import ObjectMetadata
 from nautobot.ipam.models import Prefix
 from nautobot.users.models import ObjectPermission
 
@@ -438,6 +441,16 @@ class LogsCleanupTestCase(TransactionTestCase):
         if JobResult.objects.count() < 2:
             JobResultFactory.create_batch(20)
 
+    @load_event_broker_override_settings(
+        EVENT_BROKERS={
+            "SyslogEventBroker": {
+                "CLASS": "nautobot.core.events.SyslogEventBroker",
+                "TOPICS": {
+                    "INCLUDE": ["*"],
+                },
+            }
+        }
+    )
     def test_cleanup_without_permission(self):
         """Job should enforce user permissions on the content-types being deleted."""
         job_result_count = JobResult.objects.count()
@@ -458,13 +471,14 @@ class LogsCleanupTestCase(TransactionTestCase):
         self.assertGreater(JobLogEntry.objects.count(), job_log_entry_count)
         self.assertEqual(ObjectChange.objects.count(), object_change_count)
 
-        job_result = create_job_result_and_run_job(
-            "nautobot.core.jobs.cleanup",
-            "LogsCleanup",
-            username=self.user.username,
-            cleanup_types=[CleanupTypes.OBJECT_CHANGE],
-            max_age=0,
-        )
+        with self.assertLogs("nautobot.events") as cm:
+            job_result = create_job_result_and_run_job(
+                "nautobot.core.jobs.cleanup",
+                "LogsCleanup",
+                username=self.user.username,
+                cleanup_types=[CleanupTypes.OBJECT_CHANGE],
+                max_age=0,
+            )
         self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
         log_error = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
         self.assertEqual(
@@ -474,6 +488,21 @@ class LogsCleanupTestCase(TransactionTestCase):
         self.assertGreater(JobLogEntry.objects.count(), job_log_entry_count)
         self.assertEqual(ObjectChange.objects.count(), object_change_count)
 
+        complete_logs = {
+            "job_result_id": str(job_result.id),
+            "job_name": "Logs Cleanup",
+            "user_name": self.user.username,
+            "job_kwargs": {"cleanup_types": ["extras.ObjectChange"], "max_age": 0},
+            "einfo": {
+                "exc_type": "PermissionDenied",
+                "exc_message": "User does not have delete permissions for ObjectChange records",
+            },
+        }
+        self.assertEqual(
+            cm.output[1],
+            f"INFO:nautobot.events.nautobot.jobs.job.completed:{json.dumps(complete_logs, indent=4)}",
+        )
+
     def test_cleanup_with_constrained_permission(self):
         """Job should only allow the user to cleanup records they have permission to delete."""
         job_result_1 = JobResult.objects.last()
@@ -508,20 +537,62 @@ class LogsCleanupTestCase(TransactionTestCase):
             ObjectChange.objects.get(pk=object_change_1.pk)
         ObjectChange.objects.get(pk=object_change_2.pk)
 
+    @load_event_broker_override_settings(
+        EVENT_BROKERS={
+            "SyslogEventBroker": {
+                "CLASS": "nautobot.core.events.SyslogEventBroker",
+                "TOPICS": {
+                    "INCLUDE": ["*"],
+                },
+            }
+        }
+    )
     def test_cleanup_job_results(self):
         """With unconstrained permissions, all JobResults before the cutoff should be deleted."""
         cutoff = timezone.now() - timedelta(days=60)
-        create_job_result_and_run_job(
-            "nautobot.core.jobs.cleanup",
-            "LogsCleanup",
-            cleanup_types=[CleanupTypes.JOB_RESULT],
-            max_age=60,
-        )
+        job_results_to_be_deleted = JobResult.objects.filter(date_done__lt=cutoff)
+        job_results_to_be_deleted_count = job_results_to_be_deleted.count()
+        job_log_entry_to_be_deleted_count = JobLogEntry.objects.filter(job_result__in=job_results_to_be_deleted).count()
+        objectmetadata_to_be_deleted_count = ObjectMetadata.objects.filter(
+            assigned_object_id__in=job_results_to_be_deleted,
+            assigned_object_type=ContentType.objects.get_for_model(JobResult),
+        ).count()
+
+        with self.assertLogs("nautobot.events") as cm:
+            job_result = create_job_result_and_run_job(
+                "nautobot.core.jobs.cleanup",
+                "LogsCleanup",
+                cleanup_types=[CleanupTypes.JOB_RESULT],
+                max_age=60,
+            )
         self.assertFalse(JobResult.objects.filter(date_done__lt=cutoff).exists())
         self.assertTrue(JobResult.objects.filter(date_done__gte=cutoff).exists())
         self.assertTrue(ObjectChange.objects.filter(time__lt=cutoff).exists())
         self.assertTrue(ObjectChange.objects.filter(time__gte=cutoff).exists())
 
+        started_logs = {
+            "job_result_id": str(job_result.id),
+            "job_name": "Logs Cleanup",
+            "user_name": job_result.user.username,
+            "job_kwargs": {"cleanup_types": ["extras.JobResult"], "max_age": 60},
+        }
+        self.assertEqual(
+            cm.output[0],
+            f"INFO:nautobot.events.nautobot.jobs.job.started:{json.dumps(started_logs, indent=4)}",
+        )
+
+        started_logs["job_output"] = {
+            "extras.JobResult": job_results_to_be_deleted_count,
+            "extras.JobLogEntry": job_log_entry_to_be_deleted_count,
+        }
+        if objectmetadata_to_be_deleted_count > 0:
+            started_logs["job_output"]["extras.ObjectMetadata"] = objectmetadata_to_be_deleted_count
+
+        self.assertEqual(
+            cm.output[1],
+            f"INFO:nautobot.events.nautobot.jobs.job.completed:{json.dumps(started_logs, indent=4)}",
+        )
+
     def test_cleanup_object_changes(self):
         """With unconstrained permissions, all ObjectChanges before the cutoff should be deleted."""
         cutoff = timezone.now() - timedelta(days=60)

nautobot/core/tests/test_navigations.py

@@ -1,9 +1,6 @@
-from unittest.mock import patch
-
 from django.test import tag, TestCase
 from django.urls import resolve
 
-from nautobot.core.apps import NAV_CONTEXT_NAMES, NavContext, NavGrouping, NavItem, register_new_ui_menu_items
 from nautobot.core.choices import ButtonActionColorChoices, ButtonActionIconChoices
 from nautobot.core.templatetags.helpers import bettertitle
 from nautobot.core.utils.lookup import get_route_for_model
@@ -21,7 +18,7 @@ class NavMenuTestCase(TestCase):
             for group in registry["nav_menu"]["tabs"][tab]["groups"]:
                 for item_url, item_details in registry["nav_menu"]["tabs"][tab]["groups"][group]["items"].items():
                     with self.subTest(f"{tab} > {group} > {item_url}"):
-                        view_func = resolve(item_url).func
+                        view_func = resolve(item_url.split("?")[0]).func
                         try:
                             # NautobotUIViewSet
                             view_class = view_func.view_class
@@ -34,10 +31,12 @@ class NavMenuTestCase(TestCase):
 
                             if item_details["name"] not in {
                                 "Elevations",
+                                "Example Models filtered",
                                 "Interface Connections",
                                 "Console Connections",
                                 "Power Connections",
                                 "Job Approval Queue",
+                                "Wireless Controllers",
                             }:
                                 expected_name = bettertitle(view_model._meta.verbose_name_plural)
                                 if expected_name == "VM Interfaces":
@@ -45,14 +44,16 @@ class NavMenuTestCase(TestCase):
                                 elif expected_name == "Object Changes":
                                     expected_name = "Change Log"
                                 elif expected_name == "Controller Managed Device Groups":
-                                    expected_name = "Managed Device Groups"
+                                    expected_name = "Device Groups"
                                 self.assertEqual(item_details["name"], expected_name)
                             if item_url == get_route_for_model(view_model, "list"):
                                 # Not assertEqual as some menu items have additional permissions defined.
                                 self.assertIn(get_permission_for_model(view_model, "view"), item_details["permissions"])
                         except AttributeError:
                             # Not a model view?
-                            self.assertIn(item_details["name"], {"Installed Apps", "Interface Connections"})
+                            self.assertIn(
+                                item_details["name"], {"Apps Marketplace", "Installed Apps", "Interface Connections"}
+                            )
 
                     for button, button_details in item_details["buttons"].items():
                         with self.subTest(f"{tab} > {group} > {item_url} > {button}"):
@@ -87,238 +88,3 @@ class NavMenuTestCase(TestCase):
                 else:
                     expected_perms[tab_name] |= group_perms
             self.assertEqual(expected_perms[tab_name], tab_details["permissions"])
-
-
-@tag("unit")
-class NewUINavTest(TestCase):
-    @patch.dict(registry, values={"new_ui_nav_menu": {}}, clear=True)
-    def test_build_new_ui_nav_menu(self):
-        """Assert building and adding of new ui nav to registry
-
-        Assert that:
-        1. New UI nav is added to registry["new_ui_nav_menu"]
-        2. registry["new_ui_nav_menu"] is sorted by weight
-        """
-        # Test App 1
-        navigation_1 = (
-            NavContext(
-                name="Inventory",
-                groups=(
-                    NavGrouping(
-                        name="App 1 Inventory Group 1",
-                        items=(
-                            NavItem(name="Menu 1", link="extras:relationshipassociation_list", weight="2000"),
-                            NavItem(name="Menu 3", link="extras:relationshipassociation_list", weight="100"),
-                        ),
-                    ),
-                    NavGrouping(
-                        name="App 1 Inventory Group 2",
-                        items=(
-                            NavItem(name="Menu 1", link="extras:role_list", permissions=["extras.view_role"]),
-                            NavItem(name="Menu 2", link="extras:tag_list"),
-                        ),
-                    ),
-                ),
-            ),
-            NavContext(
-                name="Security",
-                groups=(
-                    NavGrouping(
-                        name="App 1 Security Group 1",
-                        items=(
-                            NavItem(name="Menu 1", link="dcim:location_list"),
-                            NavItem(name="Menu 2", link="extras:relationshipassociation_list"),
-                            NavItem(name="Menu 3", link="extras:tag_list"),
-                        ),
-                    ),
-                ),
-            ),
-        )
-        # Test App 2
-        navigation_2 = (
-            NavContext(
-                name="Automation",
-                groups=(
-                    NavGrouping(
-                        name="App 2 Inventory Group 1",
-                        items=(
-                            NavItem(name="Tags", link="extras:tag_list"),
-                            NavItem(name="Location", link="dcim:location_list"),
-                            NavItem(name="Roles", link="extras:role_list", permissions=["extras.view_role"]),
-                        ),
-                    ),
-                ),
-            ),
-        )
-
-        for navigation in (navigation_1, navigation_2):
-            register_new_ui_menu_items(navigation)
-
-        expected_registry = {
-            "new_ui_nav_menu": {
-                "Inventory": {
-                    "weight": 1000,
-                    "data": {
-                        "App 1 Inventory Group 1": {
-                            "weight": 1000,
-                            "data": {
-                                "Menu 3": {
-                                    "name": "Menu 3",
-                                    "weight": "100",
-                                    "permissions": [],
-                                    "data": "/extras/relationship-associations/",
-                                },
-                                "Menu 1": {
-                                    "name": "Menu 1",
-                                    "weight": "2000",
-                                    "permissions": [],
-                                    "data": "/extras/relationship-associations/",
-                                },
-                            },
-                        },
-                        "App 1 Inventory Group 2": {
-                            "weight": 1000,
-                            "data": {
-                                "Menu 1": {
-                                    "name": "Menu 1",
-                                    "weight": 1000,
-                                    "permissions": ["extras.view_role"],
-                                    "data": "/extras/roles/",
-                                },
-                                "Menu 2": {
-                                    "name": "Menu 2",
-                                    "weight": 1000,
-                                    "permissions": [],
-                                    "data": "/extras/tags/",
-                                },
-                            },
-                        },
-                    },
-                },
-                "Security": {
-                    "weight": 1000,
-                    "data": {
-                        "App 1 Security Group 1": {
-                            "weight": 1000,
-                            "data": {
-                                "Menu 1": {
-                                    "name": "Menu 1",
-                                    "weight": 1000,
-                                    "permissions": [],
-                                    "data": "/dcim/locations/",
-                                },
-                                "Menu 2": {
-                                    "name": "Menu 2",
-                                    "weight": 1000,
-                                    "permissions": [],
-                                    "data": "/extras/relationship-associations/",
-                                },
-                                "Menu 3": {
-                                    "name": "Menu 3",
-                                    "weight": 1000,
-                                    "permissions": [],
-                                    "data": "/extras/tags/",
-                                },
-                            },
-                        }
-                    },
-                },
-                "Automation": {
-                    "weight": 1000,
-                    "data": {
-                        "App 2 Inventory Group 1": {
-                            "weight": 1000,
-                            "data": {
-                                "Tags": {"name": "Tags", "weight": 1000, "permissions": [], "data": "/extras/tags/"},
-                                "Location": {
-                                    "name": "Location",
-                                    "weight": 1000,
-                                    "permissions": [],
-                                    "data": "/dcim/locations/",
-                                },
-                                "Roles": {
-                                    "name": "Roles",
-                                    "weight": 1000,
-                                    "permissions": ["extras.view_role"],
-                                    "data": "/extras/roles/",
-                                },
-                            },
-                        }
-                    },
-                },
-            }
-        }
-        self.assertEqual(registry, expected_registry)
-
-    def test_validation_in_new_ui_navigation_classes(self):
-        """Test Validation on each of the new ui navigation classes `NavItem`, `NavGrouping`, `NavContext`"""
-
-        nav_item_1 = NavItem(name="Menu 1", link="extras:role_list", permissions=["extras.view_role"])
-        nav_item_2 = NavItem(name="Menu 2", link="invalid_url")
-        self.assertEqual(
-            nav_item_1.initial_dict,
-            {
-                "name": nav_item_1.name,
-                "weight": nav_item_1.weight,
-                "permissions": nav_item_1.permissions,
-                "data": nav_item_1.url(),
-            },
-        )
-        self.assertEqual(
-            nav_item_1.fixed_fields,
-            (
-                ("name", nav_item_1.name),
-                ("permissions", nav_item_1.permissions),
-            ),
-        )
-        self.assertEqual(
-            nav_item_2.initial_dict,
-            {
-                "name": nav_item_2.name,
-                "weight": nav_item_2.weight,
-                "permissions": nav_item_2.permissions,
-                "data": nav_item_2.url(),
-            },
-        )
-        self.assertEqual(
-            nav_item_2.fixed_fields,
-            (
-                ("name", nav_item_2.name),
-                ("permissions", nav_item_2.permissions),
-            ),
-        )
-
-        with self.assertRaises(TypeError) as err:
-            NavGrouping(name="Test Group", items="Invalid Items")
-        self.assertEqual(str(err.exception), "Items must be passed as a tuple or list.")
-
-        with self.assertRaises(TypeError) as err:
-            NavGrouping(name="Test Group", items=["Invalid Item"])
-        self.assertEqual(
-            str(err.exception), "All items defined in a NavGrouping must be an instance of NavItem or NavGrouping"
-        )
-
-        nav_grouping_1 = NavGrouping(name="Test Group", items=[nav_item_1], weight="200")
-        nav_grouping_2 = NavGrouping(name="Test Group", items=[nav_item_2, nav_grouping_1], weight="200")
-        self.assertEqual(nav_grouping_1.initial_dict, {"weight": nav_grouping_1.weight, "data": {}})
-        self.assertEqual(nav_grouping_1.fixed_fields, ())
-        self.assertEqual(nav_grouping_2.initial_dict, {"weight": nav_grouping_1.weight, "data": {}})
-        self.assertEqual(nav_grouping_2.fixed_fields, ())
-
-        with self.assertRaises(TypeError) as err:
-            NavContext(name="Invalid Name", groups=[])
-        self.assertEqual(
-            str(err.exception), f"`Invalid Name` is an invalid context name, valid choices are: {NAV_CONTEXT_NAMES}"
-        )
-
-        with self.assertRaises(TypeError) as err:
-            NavContext(name="Inventory", groups="Invalid Groups")
-        self.assertEqual(str(err.exception), "Groups must be passed as a tuple or list.")
-
-        with self.assertRaises(TypeError) as err:
-            NavContext(name="Inventory", groups=[NavItem(name="Menu 1", link="extras:role_list")])
-        self.assertEqual(str(err.exception), "All groups defined in a NavContext must be an instance of NavGrouping")
-
-        nav_context = NavContext(name="Inventory", groups=[nav_grouping_1, nav_grouping_2], weight="200")
-        self.assertEqual(nav_context.initial_dict, {"weight": nav_context.weight, "data": {}})
-        self.assertEqual(nav_context.fixed_fields, ())