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

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, ())

nautobot/core/tests/test_settings_schema.py

@@ -1,3 +1,4 @@
+import datetime
 import os
 import sys
 from unittest import mock, TestCase
@@ -240,6 +241,8 @@ class SettingsJSONSchemaTestCase(TestCase):
         fake = faker.Faker()
         if value_type == "boolean":
             return str(fake.boolean())
+        elif value_type == "date":
+            return datetime.date.today().isoformat()
         elif value_type == "integer":
             return str(fake.random_int())
         return f"FAKE_ENV_{fake.word()}"
@@ -252,6 +255,8 @@ class SettingsJSONSchemaTestCase(TestCase):
         # ALLOWED_HOSTS is a special case (space separated instead of commas)
         if setting_name == "ALLOWED_HOSTS":
             return os.environ[env_var].split(" ")
+        elif setting_name == "NTC_SUPPORT_CONTRACT_EXPIRATION_DATE":
+            return datetime.date.fromisoformat(os.environ[env_var])
         elif setting_type == "array":
             children_type = setting_schema.get("items", {}).get("type", "string")
             if children_type == "integer":
@@ -273,6 +278,8 @@ class SettingsJSONSchemaTestCase(TestCase):
         # ALLOWED_HOSTS is a special case (space separated instead of commas)
         if setting_name == "ALLOWED_HOSTS":
             os.environ[env_var] = " ".join(self._get_fake_env_value("string") for _ in range(3))
+        elif setting_name == "NTC_SUPPORT_CONTRACT_EXPIRATION_DATE":
+            os.environ[env_var] = self._get_fake_env_value("date")
         elif setting_type == "array":
             children_type = setting_schema.get("items", {}).get("type", "string")
             os.environ[env_var] = ",".join(self._get_fake_env_value(children_type) for _ in range(3))

nautobot/core/tests/test_tables.py

@@ -1,9 +1,15 @@
 from django.test import TestCase
 
+from nautobot.circuits.models import Circuit
+from nautobot.circuits.tables import CircuitTable
 from nautobot.core.models.querysets import count_related
 from nautobot.dcim.models import Device, InventoryItem, Location, LocationType, Rack, RackGroup
 from nautobot.dcim.tables import InventoryItemTable, LocationTable, LocationTypeTable, RackGroupTable
+from nautobot.extras.models import JobLogEntry
+from nautobot.extras.tables import JobLogEntryTable
 from nautobot.tenancy.tables import TenantGroupTable
+from nautobot.wireless.models import WirelessNetwork
+from nautobot.wireless.tables import WirelessNetworkTable
 
 
 class TableTestCase(TestCase):
@@ -63,3 +69,97 @@ class TableTestCase(TestCase):
         queryset = RackGroupTable.Meta.model.objects.annotate(rack_count=count_related(Rack, "rack_group")).all()
         self._validate_sorted_tree_queryset_same_with_table_queryset(queryset, RackGroupTable, "rack_count")
         self._validate_sorted_tree_queryset_same_with_table_queryset(queryset, RackGroupTable, "-rack_count")
+
+    def test_base_table_apis(self):
+        """
+        Test BaseTable APIs, specifically visible_columns and configurable_columns.
+        Assert that they gave the correct results.
+        """
+        # Wireless Network Table
+        wn_table = WirelessNetworkTable(WirelessNetwork.objects.all(), exclude=["enabled", "hidden"])
+        wn_table.columns.hide("description")
+        expected_visible_columns = [
+            "name",
+            "ssid",
+            "mode",
+            "authentication",
+            "actions",
+        ]
+        expected_configurable_columns = [
+            ("name", "Name"),
+            ("ssid", "SSID"),
+            ("mode", "Mode"),
+            ("authentication", "Authentication"),
+            ("secret", "Secret"),
+            ("description", "Description"),
+            ("tags", "Tags"),
+            ("dynamic_group_count", "Dynamic Groups"),
+        ]
+        self.assertEqual(wn_table.visible_columns, expected_visible_columns)
+        self.assertEqual(wn_table.configurable_columns, expected_configurable_columns)
+
+        # Location Table
+        location_table = LocationTable(Location.objects.all(), exclude=["parent", "tenant"])
+        location_table.columns.hide("description")
+        location_table.columns.hide("tags")
+        expected_visible_columns = ["name", "status", "actions"]
+        expected_configurable_columns = [
+            ("name", "Name"),
+            ("status", "Status"),
+            ("location_type", "Location type"),
+            ("description", "Description"),
+            ("facility", "Facility"),
+            ("asn", "ASN"),
+            ("time_zone", "Time zone"),
+            ("physical_address", "Physical address"),
+            ("shipping_address", "Shipping address"),
+            ("latitude", "Latitude"),
+            ("longitude", "Longitude"),
+            ("contact_name", "Contact name"),
+            ("contact_phone", "Contact phone"),
+            ("contact_email", "Contact E-mail"),
+            ("tags", "Tags"),
+            ("dynamic_group_count", "Dynamic Groups"),
+            ("cf_example_app_auto_custom_field", "Example App Automatically Added Custom Field"),
+        ]
+        self.assertEqual(location_table.visible_columns, expected_visible_columns)
+        self.assertEqual(location_table.configurable_columns, expected_configurable_columns)
+
+        # Circuit Table
+        circuit_table = CircuitTable(Circuit.objects.all(), exclude=["provider", "circuit_termination_a"])
+        circuit_table.columns.hide("tags")
+        expected_visible_columns = [
+            "cid",
+            "circuit_type",
+            "status",
+            "circuit_termination_z",
+            "description",
+            "example_app_provider_asn",
+        ]
+        expected_configurable_columns = [
+            ("cid", "ID"),
+            ("circuit_type", "Circuit type"),
+            ("status", "Status"),
+            ("tenant", "Tenant"),
+            ("circuit_termination_z", "Side Z"),
+            ("install_date", "Date installed"),
+            ("commit_rate", "Commit rate (Kbps)"),
+            ("description", "Description"),
+            ("tags", "Tags"),
+            ("example_app_provider_asn", "Provider ASN"),
+            ("dynamic_group_count", "Dynamic Groups"),
+        ]
+        self.assertEqual(circuit_table.visible_columns, expected_visible_columns)
+        self.assertEqual(circuit_table.configurable_columns, expected_configurable_columns)
+
+        # Job Log Entry Table (Job Log Entry is not Dynamic Group associable)
+        job_log_entry_table = JobLogEntryTable(JobLogEntry.objects.all(), exclude=["created", "message"])
+        job_log_entry_table.columns.hide("log_level")
+        expected_visible_columns = ["grouping", "log_object"]
+        expected_configurable_columns = [
+            ("grouping", "Grouping"),
+            ("log_level", "Level"),
+            ("log_object", "Object"),
+        ]
+        self.assertEqual(job_log_entry_table.visible_columns, expected_visible_columns)
+        self.assertEqual(job_log_entry_table.configurable_columns, expected_configurable_columns)

nautobot/core/tests/test_templatetags_helpers.py

@@ -57,6 +57,11 @@ class NautobotTemplatetagsHelperTest(TestCase):
         self.assertEqual(helpers.placeholder([]), '<span class="text-muted">&mdash;</span>')
         self.assertEqual(helpers.placeholder("something"), "something")
 
+    def test_pre_tag(self):
+        self.assertEqual(helpers.pre_tag(None), "<pre>None</pre>")
+        self.assertEqual(helpers.pre_tag([]), "<pre>[]</pre>")
+        self.assertEqual(helpers.pre_tag("something"), "<pre>something</pre>")
+
     def test_add_html_id(self):
         # Case where what we have isn't actually a HTML element but just a bare string
         self.assertEqual(helpers.add_html_id("hello", "my-id"), "hello")
@@ -322,3 +327,14 @@ class NautobotTemplatetagsHelperTest(TestCase):
             helpers.hyperlinked_object_target_new_tab(location, "foo"),
             f'<a href="/dcim/locations/{location.pk}/" title="An important location" target="_blank" rel="noreferrer">{location!s}</a>',
         )
+
+    def test_dbm(self):
+        self.assertEqual(
+            helpers.dbm(12),
+            "12 dBm",
+        )
+        self.assertEqual(
+            helpers.dbm(-85),
+            "-85 dBm",
+        )
+        self.assertEqual(helpers.dbm(None), helpers.placeholder(None))

nautobot/core/tests/test_ui.py

@@ -0,0 +1,150 @@
+"""Test cases for nautobot.core.ui module."""
+
+from unittest.mock import patch
+
+from django.template import Context
+
+from nautobot.core.templatetags.helpers import HTML_NONE
+from nautobot.core.testing import TestCase
+from nautobot.core.ui.object_detail import BaseTextPanel, DataTablePanel, Panel
+
+
+class DataTablePanelTest(TestCase):
+    def test_init(self):
+        # Minimal arguments
+        DataTablePanel(context_data_key="data", weight=100)
+
+        # Conflicting arguments
+        with self.assertRaises(ValueError):
+            DataTablePanel(context_data_key="data", weight=100, columns=[1, 2, 3], context_columns_key="columns")
+        with self.assertRaises(ValueError):
+            DataTablePanel(
+                context_data_key="data",
+                weight=100,
+                column_headers=[1, 2, 3],
+                context_column_headers_key="column_headers",
+            )
+
+        # Maximal arguments
+        DataTablePanel(context_data_key="data", weight=100, columns=[1, 2, 3], column_headers=["One", "Two", "Three"])
+        DataTablePanel(context_data_key="data", weight=100, context_columns_key="c", context_column_headers_key="ch")
+
+    def test_get_columns(self):
+        context = Context({"data": [{1: 1, 2: 2, 3: 3}, {1: 10, 2: 20, 3: 30}], "columns": [1, 3]})
+
+        self.assertEqual(DataTablePanel(context_data_key="data", weight=100).get_columns(context), [1, 2, 3])
+        self.assertEqual(
+            DataTablePanel(context_data_key="data", weight=100, columns=[1, 2]).get_columns(context), [1, 2]
+        )
+        self.assertEqual(
+            DataTablePanel(context_data_key="data", weight=100, context_columns_key="columns").get_columns(context),
+            [1, 3],
+        )
+
+    def test_get_column_headers(self):
+        context = Context(
+            {
+                "data": [{1: 1, 2: 2, 3: 3}, {1: 10, 2: 20, 3: 30}],
+                "columns": [1, 3],
+                "column_headers": ["One", "Three"],
+            }
+        )
+
+        self.assertEqual(DataTablePanel(context_data_key="data", weight=100).get_column_headers(context), [])
+        self.assertEqual(
+            DataTablePanel(context_data_key="data", weight=100, column_headers=["one", "two"]).get_column_headers(
+                context
+            ),
+            ["one", "two"],
+        )
+        self.assertEqual(
+            DataTablePanel(
+                context_data_key="data", weight=100, context_column_headers_key="column_headers"
+            ).get_column_headers(context),
+            ["One", "Three"],
+        )
+
+
+class BaseTextPanelTest(TestCase):
+    def test_init_set_object_params(self):
+        # Test default settings
+        panel = BaseTextPanel(weight=100)
+        self.assertEqual(panel.render_as, BaseTextPanel.RenderOptions.MARKDOWN)
+        self.assertTrue(panel.render_placeholder)
+
+        # Test initialization with custom arguments
+        panel = BaseTextPanel(weight=100, render_as=BaseTextPanel.RenderOptions.JSON, render_placeholder=False)
+        self.assertEqual(panel.render_as, BaseTextPanel.RenderOptions.JSON)
+        self.assertFalse(panel.render_placeholder)
+
+    @patch.object(Panel, "__init__")
+    def test_init_passes_args_and_kwargs(self, panel_init_mock):
+        custom_template_path = "custom_template_path.html"
+
+        BaseTextPanel(weight=100, body_content_template_path=custom_template_path)
+
+        panel_init_mock.assert_called_once_with(weight=100, body_content_template_path=custom_template_path)
+
+    @patch.object(BaseTextPanel, "get_value")
+    def test_render_body_content(self, get_value_mock):
+        test_cases = [
+            {
+                "render_as": BaseTextPanel.RenderOptions.JSON,
+                "value": {"key": "value"},
+                "expected_output": '<pre><code class="language-json">{    &quot;key&quot;: &quot;value&quot; }</code></pre>',
+            },
+            {
+                "render_as": BaseTextPanel.RenderOptions.YAML,
+                "value": {"key": "value"},
+                "expected_output": '<pre><code class="language-yaml">key: value</code></pre>',
+            },
+            {
+                "render_as": BaseTextPanel.RenderOptions.MARKDOWN,
+                "value": "# Header",
+                "expected_output": "<h1>Header</h1>",
+            },
+            {
+                "render_as": BaseTextPanel.RenderOptions.CODE,
+                "value": "print('Hello, world!')",
+                "expected_output": "<pre>print(&#x27;Hello, world!&#x27;)</pre>",
+            },
+            {
+                "render_as": BaseTextPanel.RenderOptions.PLAINTEXT,
+                "value": "Simple text",
+                "expected_output": "Simple text",
+            },
+        ]
+
+        for case in test_cases:
+            with self.subTest(render_as=case["render_as"]):
+                panel = BaseTextPanel(weight=100, render_as=case["render_as"])
+
+                get_value_mock.return_value = case["value"]
+                context = Context()
+
+                result = panel.render_body_content(context)
+
+                self.assertHTMLEqual(result, case["expected_output"])
+
+    @patch.object(BaseTextPanel, "get_value")
+    def test_render_body_content_render_placeholder(self, get_value_mock):
+        get_value_mock.return_value = ""
+        context = Context()
+
+        panel = BaseTextPanel(weight=100, render_as=BaseTextPanel.RenderOptions.PLAINTEXT)
+
+        self.assertHTMLEqual(panel.render_body_content(context), HTML_NONE)
+
+    @patch.object(BaseTextPanel, "get_value")
+    def test_render_body_content_not_render_placeholder(self, get_value_mock):
+        get_value_mock.return_value = ""
+        context = Context()
+
+        panel = BaseTextPanel(weight=100, render_as=BaseTextPanel.RenderOptions.PLAINTEXT, render_placeholder=False)
+
+        self.assertHTMLEqual(panel.render_body_content(context), "")
+
+    def test_get_value(self):
+        panel = BaseTextPanel(weight=100)
+        with self.assertRaises(NotImplementedError):
+            panel.get_value({})