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

nautobot/core/tests/test_jobs.py

@@ -8,6 +8,7 @@ from django.core.files.base import ContentFile
 from django.utils import timezone
 import yaml
 
+from nautobot.circuits.models import Circuit, CircuitType, Provider
 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
@@ -24,9 +25,10 @@ from nautobot.extras.models import (
     ObjectChange,
     Role,
     Status,
+    Tag,
 )
 from nautobot.extras.models.metadata import ObjectMetadata
-from nautobot.ipam.models import Prefix
+from nautobot.ipam.models import IPAddress, Namespace, Prefix
 from nautobot.users.models import ObjectPermission
 
 
@@ -606,3 +608,460 @@ class LogsCleanupTestCase(TransactionTestCase):
         self.assertTrue(JobResult.objects.filter(date_done__gte=cutoff).exists())
         self.assertFalse(ObjectChange.objects.filter(time__lt=cutoff).exists())
         self.assertTrue(ObjectChange.objects.filter(time__gte=cutoff).exists())
+
+
+class BulkEditTestCase(TransactionTestCase):
+    """
+    Test the BulkEdit system job.
+    """
+
+    def setUp(self):
+        super().setUp()
+        self.status_ct = ContentType.objects.get_for_model(Status)
+        self.namespace_ct = ContentType.objects.get_for_model(Namespace)
+        self.role_ct = ContentType.objects.get_for_model(Role)
+        self.ipaddress_ct = ContentType.objects.get_for_model(IPAddress)
+        self.tags = [Tag.objects.create(name=f"Example Tag {x}") for x in range(5)]
+        for tag in self.tags:
+            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.assertEqual(model.objects.filter(**filter_params).count(), expected_count)
+        self.assertFalse(
+            JobLogEntry.objects.filter(job_result=job_result, log_level=LogLevelChoices.LOG_WARNING).exists()
+        )
+        self.assertFalse(
+            JobLogEntry.objects.filter(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR).exists()
+        )
+
+    def test_bulk_edit_objects_without_permission(self):
+        statuses = [Status.objects.create(name=f"Sample Status {x}") for x in range(3)]
+        pk_list = [str(status.id) for status in statuses]
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkEditObjects",
+            content_type=self.status_ct.id,
+            edit_all=False,
+            filter_query_params={},
+            form_data={"pk": pk_list, "color": "aa1409"},
+            username=self.user.username,
+        )
+        self.assertEqual(job_result.status, 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')
+
+        # Assert status did not get updated
+        for status in statuses:
+            status.refresh_from_db()
+            self.assertNotEqual(status.color, "aa1409")
+
+    def test_bulk_edit_objects_with_constrained_permission(self):
+        roles_to_update = [
+            Role.objects.create(name="Example Role 1"),
+            Role.objects.create(name="Example Role 2"),
+        ]
+        pk_list = [str(role.pk) for role in roles_to_update]
+
+        obj_perm = ObjectPermission.objects.create(
+            name="Test permission",
+            constraints={"pk": pk_list[0]},
+            actions=["change", "view"],
+        )
+        obj_perm.users.add(self.user)
+        obj_perm.object_types.add(self.role_ct)
+
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkEditObjects",
+            content_type=self.role_ct.id,
+            edit_all=False,
+            filter_query_params={"per_page": 2},
+            form_data={"pk": pk_list, "color": "aa1409"},
+            username=self.user.username,
+        )
+        error_log = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
+        self.assertIn("Form validation unsuccessful", error_log.message)
+        self.assertIn(f"{roles_to_update[1].pk} is not one of the available choices.", error_log.message)
+        roles_to_update[0].refresh_from_db()
+        roles_to_update[1].refresh_from_db()
+        self.assertNotEqual(roles_to_update[0].color, "aa1409")
+        self.assertNotEqual(roles_to_update[1].color, "aa1409")
+
+        obj_perm.constraints = {"pk__in": pk_list}
+        obj_perm.save()
+
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkEditObjects",
+            content_type=self.role_ct.id,
+            edit_all=False,
+            filter_query_params={"sort": "name"},
+            form_data={"pk": pk_list, "color": "aa1409"},
+            username=self.user.username,
+        )
+        self._common_no_error_test_assertion(Role, job_result, 2, pk__in=pk_list, color="aa1409")
+
+    def test_bulk_edit_objects_select_all(self):
+        """
+        Bulk edit all Role instances.
+        """
+        self.add_permissions("extras.change_role", "extras.view_role")
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkEditObjects",
+            content_type=self.role_ct.id,
+            edit_all=True,
+            filter_query_params={},
+            form_data={"color": "aa1409"},
+            username=self.user.username,
+        )
+        self._common_no_error_test_assertion(Role, job_result, Role.objects.all().count(), color="aa1409")
+
+    def test_bulk_edit_select_some(self):
+        """
+        Bulk edit selected Namespace instances.
+        """
+        self.add_permissions("ipam.change_namespace", "ipam.view_namespace", "extras.change_tag", "extras.view_tag")
+        namespaces = [Namespace.objects.create(name=f"Sample Namespace {x}") for x in range(5)]
+        for namespace in namespaces:
+            namespace.tags.set(self.tags[3:])
+        pk_list = [str(status.id) for status in namespaces[:3]]
+
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkEditObjects",
+            content_type=self.namespace_ct.id,
+            edit_all=False,
+            filter_query_params={},
+            form_data={
+                "pk": pk_list,
+                "description": "Example description for bulk edit",
+                "add_tags": [str(tag.id) for tag in self.tags[:3]],
+                "remove_tags": [str(tag.id) for tag in self.tags[3:]],
+            },
+            username=self.user.username,
+        )
+
+        self._common_no_error_test_assertion(
+            Namespace,
+            job_result,
+            3,
+            description="Example description for bulk edit",
+        )
+
+        # Assert Namespaces withing pk_list updated tags
+        for namespace in namespaces[:3]:
+            self.assertTrue(namespace.tags.filter(pk__in=[tag.pk for tag in self.tags[:3]]).exists())
+            self.assertFalse(namespace.tags.filter(pk__in=[tag.pk for tag in self.tags[3:]]).exists())
+
+        # Assert Namespaces not withing pk_list tags did not get updated
+        for namespace in namespaces[3:]:
+            self.assertFalse(namespace.tags.filter(pk__in=[tag.pk for tag in self.tags[:3]]).exists())
+            self.assertTrue(namespace.tags.filter(pk__in=[tag.pk for tag in self.tags[3:]]).exists())
+
+    def test_bulk_edit_objects_filter_all(self):
+        """
+        Bulk edit all of the filtered Status instances.
+        """
+        self.add_permissions("extras.change_status", "extras.view_status")
+        # By default Active and Available are some of the example of Status that starts with A
+        statuses = Status.objects.filter(name__istartswith="A")
+        status_to_ignore = Status.objects.create(name="Ignore Example Status")
+        self.assertNotEqual(statuses.count(), 0)
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkEditObjects",
+            content_type=self.status_ct.id,
+            edit_all=True,
+            filter_query_params={"name__isw": "A"},
+            form_data={
+                "color": "aa1409",
+                "_all": "True",
+            },
+            username=self.user.username,
+        )
+        self._common_no_error_test_assertion(
+            Status, job_result, statuses.count(), name__istartswith="A", color="aa1409"
+        )
+        self.assertNotEqual(status_to_ignore.color, "aa1409")
+
+    def test_bulk_edit_objects_filter_some(self):
+        """
+        Bulk edit some of the filtered Status instances.
+        """
+        self.add_permissions("extras.change_status", "extras.view_status")
+        # By default Active and Available are some of the example of Status that starts with A
+        statuses = Status.objects.filter(name__istartswith="A")
+        status_to_ignore = Status.objects.create(name="Ignore Example Status")
+        self.assertNotEqual(statuses.count(), 0)
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkEditObjects",
+            content_type=self.status_ct.id,
+            edit_all=False,
+            filter_query_params={"name__isw": "A", "sort": "name"},
+            form_data={
+                "pk": [str(statuses[0].pk)],
+                "color": "aa1409",
+            },
+            username=self.user.username,
+        )
+        self._common_no_error_test_assertion(Status, job_result, 1, name__istartswith="A", color="aa1409")
+        self.assertNotEqual(status_to_ignore.color, "aa1409")
+
+    def test_bulk_edit_objects_passing_in_both_pk_list_and_edit_all(self):
+        """
+        edit_all should override pk if both are passed.
+        """
+        self.add_permissions("extras.change_status", "extras.view_status")
+        # By default Active and Available are some of the example of Status that starts with A
+        statuses = Status.objects.filter(name__istartswith="A")
+        status_to_ignore = Status.objects.create(name="Ignore Example Status")
+        self.assertNotEqual(statuses.count(), 0)
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkEditObjects",
+            content_type=self.status_ct.id,
+            edit_all=True,
+            filter_query_params={"name__isw": "A"},
+            # pk ignored if edit_all is True
+            form_data={
+                "pk": [str(statuses[0].pk)],
+                "color": "aa1409",
+                "_all": "True",
+            },
+            username=self.user.username,
+        )
+        self._common_no_error_test_assertion(
+            Status, job_result, statuses.count(), name__istartswith="A", color="aa1409"
+        )
+        self.assertNotEqual(status_to_ignore.color, "aa1409")
+
+    def test_bulk_edit_objects_updating_the_same_field_as_the_filter_param(self):
+        """
+        Test bulk edit where the filter query param and the field to update are the same.
+        e.g.
+        form_data = {"status": "Test Deprecated"}
+        filter_params = {"status": "Test Active"}
+        """
+        self.add_permissions("ipam.change_ipaddress", "extras.view_status")
+        # By default Active and Available are some of the example of Status that starts with A
+        active_status = Status.objects.create(name="Test Active")
+        deprecated_status = Status.objects.create(name="Test Deprecated")
+        active_status.content_types.add(self.ipaddress_ct)
+        deprecated_status.content_types.add(self.ipaddress_ct)
+        IPAddress.objects.all().update(status=active_status)
+        self.assertEqual(IPAddress.objects.all().count(), IPAddress.objects.filter(status=active_status).count())
+
+        # Update all IPAddresses with status=active_status to deprecated_statuses with no filters
+        create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkEditObjects",
+            content_type=self.ipaddress_ct.id,
+            edit_all=True,
+            # pk ignored if edit_all is True
+            form_data={
+                "status": str(deprecated_status.pk),
+                "_all": "True",
+            },
+            username=self.user.username,
+        )
+        self.assertEqual(IPAddress.objects.all().count(), IPAddress.objects.filter(status=deprecated_status).count())
+        # Update all IPAddresses with status=active_status to deprecated_statuses with status filter applied
+        create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkEditObjects",
+            content_type=self.ipaddress_ct.id,
+            edit_all=True,
+            filter_query_params={"status": "Test Deprecated"},
+            # pk ignored if edit_all is True
+            form_data={
+                "status": str(active_status.pk),
+                "per_page": 1,
+                "_all": "True",
+            },
+            username=self.user.username,
+        )
+        self.assertEqual(IPAddress.objects.all().count(), IPAddress.objects.filter(status=active_status).count())
+
+
+class BulkDeleteTestCase(TransactionTestCase):
+    """
+    Test the BulkDeleteObjects system job.
+    """
+
+    def setUp(self):
+        super().setUp()
+        self.status_ct = ContentType.objects.get_for_model(Status)
+        self.role_ct = ContentType.objects.get_for_model(Role)
+        for x in range(10):
+            Status.objects.create(name=f"Example Status {x}")
+
+        statuses = Status.objects.get_for_model(Circuit)
+        circuit_type = CircuitType.objects.create(
+            name="Example Circuit Type",
+        )
+        provider = Provider.objects.create(
+            name="Example Provider",
+        )
+
+        Circuit.objects.create(
+            cid="Circuit 1",
+            provider=provider,
+            circuit_type=circuit_type,
+            status=statuses[0],
+        )
+        Circuit.objects.create(
+            cid="Circuit 2",
+            provider=provider,
+            circuit_type=circuit_type,
+            status=statuses[0],
+        )
+        Circuit.objects.create(
+            cid="Circuit 3",
+            provider=provider,
+            circuit_type=circuit_type,
+            status=statuses[0],
+        )
+
+    def _common_no_error_test_assertion(self, model, job_result, **filter_params):
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertEqual(model.objects.filter(**filter_params).count(), 0)
+        self.assertFalse(
+            JobLogEntry.objects.filter(job_result=job_result, log_level=LogLevelChoices.LOG_WARNING).exists()
+        )
+        self.assertFalse(
+            JobLogEntry.objects.filter(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR).exists()
+        )
+
+    def test_bulk_delete_objects_without_permission(self):
+        statuses_to_delete = [str(status) for status in Status.objects.all().values_list("pk", flat=True)[:2]]
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkDeleteObjects",
+            content_type=self.status_ct.id,
+            pk_list=statuses_to_delete,
+            username=self.user.username,
+        )
+        self.assertEqual(job_result.status, 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))
+
+    def test_bulk_delete_objects_with_constrained_permission(self):
+        statuses_to_delete = [str(status) for status in Status.objects.all().values_list("pk", flat=True)[:2]]
+        obj_perm = ObjectPermission(
+            name="Test permission",
+            constraints={"pk": str(statuses_to_delete[0])},
+            actions=["delete"],
+        )
+        obj_perm.save()
+        obj_perm.users.add(self.user)
+        obj_perm.object_types.add(ContentType.objects.get_for_model(Status))
+
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkDeleteObjects",
+            content_type=self.status_ct.id,
+            pk_list=statuses_to_delete,
+            username=self.user.username,
+        )
+        self.assertEqual(job_result.status, 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`."
+        )
+        self.assertEqual(Status.objects.filter(pk__in=statuses_to_delete).count(), len(statuses_to_delete))
+
+    def test_bulk_delete_objects_select_all(self):
+        """
+        Delete all Circuits objects.
+        """
+        self.add_permissions("circuits.delete_circuit")
+        # Assert Circuit is not empty
+        self.assertNotEqual(Circuit.objects.all().count(), 0)
+
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkDeleteObjects",
+            content_type=ContentType.objects.get_for_model(Circuit).id,
+            delete_all=True,
+            filter_query_params={"per_page": 10},
+            pk_list=[],
+            username=self.user.username,
+        )
+        self._common_no_error_test_assertion(Circuit, job_result)
+
+    def test_bulk_delete_objects_select_some(self):
+        """
+        Delete some of the Role objects with no filter queries applied.
+        """
+        self.add_permissions("extras.delete_role")
+        roles_to_delete = [Role.objects.create(name=f"Example Role {x}") for x in range(3)]
+        roles_to_ignore = Role.objects.create(name="Ignore Example Role")
+        roles_pks = [str(role.pk) for role in roles_to_delete]
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkDeleteObjects",
+            content_type=self.role_ct.id,
+            delete_all=False,
+            filter_query_params={},
+            pk_list=roles_pks,
+            username=self.user.username,
+        )
+        self._common_no_error_test_assertion(Role, job_result, pk__in=roles_pks)
+        self.assertTrue(Role.objects.filter(name=roles_to_ignore.name).exists())
+
+    def test_bulk_delete_objects_filter_all(self):
+        """
+        Delete all of the Status objects that start with "Example Status".
+        """
+        self.add_permissions("extras.delete_status")
+        status_to_ignore = Status.objects.create(name="Ignore Example Status")
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkDeleteObjects",
+            content_type=self.status_ct.id,
+            delete_all=True,
+            filter_query_params={"name__isw": "Example Status", "sort": "name"},
+            username=self.user.username,
+        )
+        self._common_no_error_test_assertion(Status, job_result, name__istartswith="Example Status")
+        self.assertTrue(Status.objects.filter(name=status_to_ignore.name).exists())
+
+    def test_bulk_delete_objects_filter_some(self):
+        """
+        Delete some of the Role objects that start with "Example Status".
+        """
+        self.add_permissions("extras.delete_role")
+        roles_to_delete = [Role.objects.create(name=f"Example Role {x}") for x in range(3)]
+        roles_to_ignore = Role.objects.create(name="Ignore Example Role")
+        roles_pks = [str(role.pk) for role in roles_to_delete]
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkDeleteObjects",
+            content_type=self.role_ct.id,
+            delete_all=False,
+            filter_query_params={"name__isw": "Example Status"},
+            pk_list=roles_pks,
+            username=self.user.username,
+        )
+        self._common_no_error_test_assertion(Role, job_result, pk__in=roles_pks)
+        self.assertTrue(Role.objects.filter(name=roles_to_ignore.name).exists())
+
+    def test_bulk_delete_objects_passing_both_pk_list_and_delete_all(self):
+        """
+        delete_all should override pk_list if both are passed.
+        """
+        self.add_permissions("extras.delete_status")
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.bulk_actions",
+            "BulkDeleteObjects",
+            content_type=self.status_ct.pk,
+            delete_all=True,
+            filter_query_params={"name__isw": "Example Status", "sort": "name"},
+            pk_list=[str(Status.objects.first().pk)],
+            username=self.user.username,
+        )
+        self._common_no_error_test_assertion(Role, job_result, name__istartswith="Example Status")

nautobot/core/tests/test_models.py

@@ -72,6 +72,15 @@ class NaturalKeyTestCase(BaseModelTest):
         dt = DeviceType.objects.first()
         self.assertEqual(dt.natural_key(), [dt.manufacturer.name, dt.model])
 
+    def test_natural_key_with_proxy_model(self):
+        """Test that natural_key_field_lookups function returns the same value as its base class."""
+
+        class ProxyManufacturer(Manufacturer):
+            class Meta:
+                proxy = True
+
+        self.assertEqual(ProxyManufacturer.natural_key_field_lookups, Manufacturer.natural_key_field_lookups)
+
     @skip("Composite keys aren't being supported at this time")
     def test_composite_key(self):
         """Test the composite_key default implementation with some representative models."""

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)