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

nautobot/core/tests/test_api.py

@@ -3,7 +3,6 @@ from io import BytesIO, StringIO
 import json
 import os
 from unittest import skip
-import uuid
 
 from constance import config
 from constance.test import override_config
@@ -15,7 +14,6 @@ from django.urls import reverse
 from rest_framework import status
 from rest_framework.exceptions import ParseError
 from rest_framework.settings import api_settings
-from rest_framework.test import APIRequestFactory, force_authenticate
 import yaml
 
 from nautobot.circuits.models import Provider
@@ -24,14 +22,13 @@ from nautobot.core.api.parsers import NautobotCSVParser
 from nautobot.core.api.renderers import NautobotCSVRenderer
 from nautobot.core.api.utils import get_serializer_for_model, get_view_name
 from nautobot.core.api.versioning import NautobotAPIVersioning
-from nautobot.core.api.views import ModelViewSet
 from nautobot.core.constants import COMPOSITE_KEY_SEPARATOR
 from nautobot.core.templatetags.helpers import humanize_speed
 from nautobot.core.utils.lookup import get_route_for_model
 from nautobot.dcim import models as dcim_models
 from nautobot.dcim.api import serializers as dcim_serializers
 from nautobot.extras import choices, models as extras_models
-from nautobot.ipam import filters as ipam_filters, models as ipam_models
+from nautobot.ipam import models as ipam_models
 from nautobot.ipam.api import serializers as ipam_serializers, views as ipam_api_views
 from nautobot.tenancy import models as tenancy_models
 
@@ -384,7 +381,6 @@ class GenerateLookupValueDomElementViewTestCase(testing.APITestCase):
             (
                 '<select name="role" class="form-control nautobot-select2-api" data-multiple="1" '
                 'data-query-param-content_types="[&quot;dcim.device&quot;, &quot;virtualization.virtualmachine&quot;]" '
-                'data-query-param-exclude_m2m="[&quot;true&quot;]" '
                 'display-field="display" value-field="name" data-depth="0" data-url="/api/extras/roles/" id="id_for_role" '
                 "multiple>\n</select>"
             ),
@@ -520,80 +516,6 @@ class NautobotCSVRendererTest(TestCase):
         self.assertEqual(read_data["parent__name"], location_type.parent.name)
 
 
-class ModelViewSetMixinTest(testing.APITestCase):
-    """Unit tests for ModelViewSetMixin, base class for ModelViewSet/ReadOnlyModelViewSet classes."""
-
-    class SimpleIPAddressViewSet(ModelViewSet):
-        queryset = ipam_models.IPAddress.objects.all()  # no explicit optimizations
-        serializer_class = ipam_serializers.IPAddressSerializer
-        filterset_class = ipam_filters.IPAddressFilterSet
-
-    def test_get_queryset_optimizations(self):
-        """Test that the queryset is appropriately optimized based on request parameters."""
-        self.user.is_superuser = True
-        self.user.save()
-
-        # Default behavior - m2m fields included
-        view = self.SimpleIPAddressViewSet()
-        view.action_map = {"get": "list"}
-        request = APIRequestFactory().get(reverse("ipam-api:ipaddress-list"), headers=self.header)
-        force_authenticate(request, user=self.user)
-        request = view.initialize_request(request)
-        view.setup(request)
-        view.initial(request)
-
-        queryset = view.get_queryset()
-        with self.assertNumQueries(5):  # IPAddress plus four prefetches
-            instance = queryset.first()
-        # FK related objects should have been auto-selected
-        with self.assertNumQueries(0):
-            instance.status
-            instance.role
-            instance.parent
-            instance.tenant
-            instance.nat_inside
-        # Reverse relations should have been auto-prefetched
-        with self.assertNumQueries(0):
-            list(instance.nat_outside_list.all())
-        # Many-to-many relations should have been auto-prefetched
-        with self.assertNumQueries(0):
-            list(instance.interfaces.all())
-            list(instance.vm_interfaces.all())
-            list(instance.tags.all())
-
-        # With exclude_m2m query parameter
-        view = self.SimpleIPAddressViewSet()
-        view.action_map = {"get": "list"}
-        request = APIRequestFactory().get(
-            reverse("ipam-api:ipaddress-list"), headers=self.header, data={"exclude_m2m": True}
-        )
-        force_authenticate(request, user=self.user)
-        request = view.initialize_request(request)
-        view.setup(request)
-        view.initial(request)
-
-        queryset = view.get_queryset()
-        with self.assertNumQueries(1):  # IPAddress only, no prefetches
-            instance = queryset.first()
-        # FK related objects should still have been auto-selected
-        with self.assertNumQueries(0):
-            instance.status
-            instance.role
-            instance.parent
-            instance.tenant
-            instance.nat_inside
-        # Reverse relations should NOT have been auto-prefetched
-        with self.assertNumQueries(1):
-            list(instance.nat_outside_list.all())
-        # Many-to-many relations should NOT have been auto-prefetched
-        with self.assertNumQueries(1):
-            list(instance.interfaces.all())
-        with self.assertNumQueries(1):
-            list(instance.vm_interfaces.all())
-        with self.assertNumQueries(1):
-            list(instance.tags.all())
-
-
 class WritableNestedSerializerTest(testing.APITestCase):
     """
     Test the operation of WritableNestedSerializer using VLANSerializer as our test subject.
@@ -766,25 +688,6 @@ class WritableNestedSerializerTest(testing.APITestCase):
         self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
         self.assertEqual(ipam_models.VLAN.objects.filter(name="Test VLAN 100").count(), 0)
 
-    def test_create_with_specified_id(self):
-        data = {
-            "id": str(uuid.uuid4()),
-            "vid": 400,
-            "name": "Test VLAN 400",
-            "status": self.statuses.first().pk,
-            "vlan_group": self.vlan_group1.pk,
-        }
-        url = reverse("ipam-api:vlan-list")
-        self.add_permissions("ipam.add_vlan")
-
-        response = self.client.post(url, data, format="json", **self.header)
-        self.assertHttpStatus(response, status.HTTP_201_CREATED)
-        self.assertEqual(str(response.data["vlan_group"]["url"]), self.absolute_api_url(self.vlan_group1))
-        self.assertEqual(str(response.data["id"]), data["id"])
-        vlan = ipam_models.VLAN.objects.get(pk=response.data["id"])
-        self.assertEqual(vlan.status, self.statuses.first())
-        self.assertEqual(vlan.vlan_group, self.vlan_group1)
-
 
 class APIOrderingTestCase(testing.APITestCase):
     """

nautobot/core/tests/test_csv.py

@@ -1,6 +1,3 @@
-import csv
-import io
-
 from django.contrib.contenttypes.models import ContentType
 from django.test import override_settings, RequestFactory, TestCase
 from django.urls import reverse
@@ -264,28 +261,9 @@ class CSVParsingRelatedTestCase(TestCase):
         self.assertEqual(response.status_code, 200)
         response_data = response.content.decode(response.charset)
 
-        # parse the csv data
-        csv_reader = csv.DictReader(response_data.splitlines())
-        # remove the 'id' column so that all the items are imported new
-        fieldnames = [field for field in csv_reader.fieldnames if field != "id"]
-        # read all entries into a list
-        response_csv = list(csv_reader)
-
-        # mutate our data for testing purposes
-        for row in response_csv:
-            if row["name"] == "TestDevice1":
-                row["name"] = "TestDevice3"
-            elif row["name"] == "TestDevice2":
-                row["name"] = ""
-
-        # prep our data to write out
-        with io.StringIO() as import_csv:
-            writer = csv.DictWriter(import_csv, fieldnames=fieldnames)
-            writer.writeheader()
-            for row in response_csv:
-                filtered_row = {key: row[key] for key in fieldnames}
-                writer.writerow(filtered_row)
-            data = {"csv_data": import_csv.getvalue()}
+        # Replace Device Name
+        import_data = response_data.replace("TestDevice1", "TestDevice3").replace("TestDevice2", "")
+        data = {"csv_data": import_data}
         url = reverse("dcim:device_import")
         response = self.client.post(url, data)
         self.assertEqual(response.status_code, 200)

nautobot/core/tests/test_forms.py

@@ -806,7 +806,6 @@ class DynamicFilterFormTest(TestCase):
                     "data-depth": 0,
                     "data-multiple": 1,
                     "data-query-param-content_types": '["dcim.location"]',
-                    "data-query-param-exclude_m2m": '["true"]',
                     "display-field": "display",
                     "value-field": "name",
                 },

nautobot/core/tests/test_jobs.py

@@ -24,10 +24,9 @@ from nautobot.extras.models import (
     ObjectChange,
     Role,
     Status,
-    Tag,
 )
 from nautobot.extras.models.metadata import ObjectMetadata
-from nautobot.ipam.models import Namespace, Prefix
+from nautobot.ipam.models import Prefix
 from nautobot.users.models import ObjectPermission
 
 
@@ -607,304 +606,3 @@ 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.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_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_all(self):
-        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_filter_all(self):
-        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_with_pk(self):
-        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_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={},
-            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={},
-            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")
-
-
-class BulkDeleteTestCase(TransactionTestCase):
-    """
-    Test the BulkDelete 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)
-        self.device_ct = ContentType.objects.get_for_model(Device)
-
-    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_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_all(self):
-        self.add_permissions("extras.delete_objectmetadata")
-
-        # Assert ObjectMetadata is not empty
-        self.assertNotEqual(ObjectMetadata.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(ObjectMetadata).id,
-            delete_all=True,
-            filter_query_params={},
-            pk_list=[],
-            username=self.user.username,
-        )
-        self._common_no_error_test_assertion(ObjectMetadata, job_result)
-
-    def test_bulk_delete_filter_all(self):
-        self.add_permissions("extras.delete_status")
-        for x in range(10):
-            Status.objects.create(name=f"Example Status {x}")
-
-        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"},
-            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_passing_both_pk_list_and_delete_all(self):
-        self.add_permissions("extras.delete_status")
-        status_count = Status.objects.all().count()
-        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"},
-            pk_list=[str(Status.objects.first().pk)],
-            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,
-            "You can either delete objs within `pk_list` provided or `delete_all` with `filter_query_params` if needed.",
-        )
-        self.assertEqual(status_count, Status.objects.all().count())
-
-    def test_bulk_delete_with_pk(self):
-        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())

nautobot/core/tests/test_settings_schema.py

@@ -1,4 +1,3 @@
-import datetime
 import os
 import sys
 from unittest import mock, TestCase
@@ -241,8 +240,6 @@ 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()}"
@@ -255,8 +252,6 @@ 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":
@@ -278,8 +273,6 @@ 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,15 +1,9 @@
 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):
@@ -69,97 +63,3 @@ 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)