nautobot 2.0.0a3__py3-none-any.whl → 2.0.0b1__py3-none-any.whl

nautobot/core/tests/test_graphql.py

@@ -82,10 +82,17 @@ class GraphQLTestCase(TestCase):
         GraphQLQuery.objects.create(name="GQL 1", query="{ query: locations {name} }")
         GraphQLQuery.objects.create(name="GQL 2", query="query ($name: [String!]) { locations(name:$name) {name} }")
         self.location_type = LocationType.objects.get(name="Campus")
+        location_status = Status.objects.get_for_model(Location).first()
         self.locations = (
-            Location.objects.create(name="Location-1", slug="location-1", location_type=self.location_type),
-            Location.objects.create(name="Location-2", slug="location-2", location_type=self.location_type),
-            Location.objects.create(name="Location-3", slug="location-3", location_type=self.location_type),
+            Location.objects.create(
+                name="Location-1", slug="location-1", location_type=self.location_type, status=location_status
+            ),
+            Location.objects.create(
+                name="Location-2", slug="location-2", location_type=self.location_type, status=location_status
+            ),
+            Location.objects.create(
+                name="Location-3", slug="location-3", location_type=self.location_type, status=location_status
+            ),
         )
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
@@ -228,7 +235,6 @@ class GraphQLExtendSchemaType(TestCase):
         self.assertIsInstance(getattr(schema, "resolve_mode"), types.FunctionType)
 
 
-@skip("Something really funky is broken here. Setup fails due to content types not existing...")
 class GraphQLExtendSchemaRelationship(TestCase):
     def setUp(self):
         location_ct = ContentType.objects.get_for_model(Location)
@@ -236,8 +242,8 @@ class GraphQLExtendSchemaRelationship(TestCase):
         vlan_ct = ContentType.objects.get_for_model(VLAN)
 
         self.m2m_1 = Relationship(
-            name="Vlan to Rack",
-            slug="vlan-rack",
+            label="Vlan to Rack",
+            key="vlan_rack",
             source_type=rack_ct,
             source_label="My Vlans",
             destination_type=vlan_ct,
@@ -247,8 +253,8 @@ class GraphQLExtendSchemaRelationship(TestCase):
         self.m2m_1.validated_save()
 
         self.m2m_2 = Relationship(
-            name="Another Vlan to Rack",
-            slug="vlan-rack-2",
+            label="Another Vlan to Rack",
+            key="vlan_rack_2",
             source_type=rack_ct,
             destination_type=vlan_ct,
             type="many-to-many",
@@ -256,8 +262,8 @@ class GraphQLExtendSchemaRelationship(TestCase):
         self.m2m_2.validated_save()
 
         self.o2m_1 = Relationship(
-            name="generic location to vlan",
-            slug="location-vlan",
+            label="generic location to vlan",
+            key="location_vlan",
             source_type=location_ct,
             destination_type=vlan_ct,
             type="one-to-many",
@@ -265,8 +271,8 @@ class GraphQLExtendSchemaRelationship(TestCase):
         self.o2m_1.validated_save()
 
         self.o2o_1 = Relationship(
-            name="Primary Rack per Location",
-            slug="primary-rack-location",
+            label="Primary Rack per Location",
+            key="primary_rack_location",
             source_type=rack_ct,
             source_hidden=True,
             destination_type=location_ct,
@@ -276,8 +282,8 @@ class GraphQLExtendSchemaRelationship(TestCase):
         self.o2o_1.validated_save()
 
         self.o2os_1 = Relationship(
-            name="Redundant Location",
-            slug="redundant-location",
+            label="Redundant Location",
+            key="redundant_location",
             source_type=location_ct,
             destination_type=location_ct,
             type="symmetric-one-to-one",
@@ -285,8 +291,8 @@ class GraphQLExtendSchemaRelationship(TestCase):
         self.o2os_1.validated_save()
 
         self.o2m_same_type_1 = Relationship(
-            name="Some sort of location hierarchy?",
-            slug="location-hierarchy",
+            label="Some sort of location hierarchy?",
+            key="location_hierarchy",
             source_type=location_ct,
             destination_type=location_ct,
             type="one-to-many",
@@ -306,7 +312,7 @@ class GraphQLExtendSchemaRelationship(TestCase):
             (self.m2m_2, "source"),
             (self.o2m_1, "source"),
         ]:
-            field_name = f"rel_{str_to_var_name(rel.slug)}"
+            field_name = f"rel_{str_to_var_name(rel.key)}"
             self.assertIn(field_name, schema._meta.fields.keys())
             self.assertIsInstance(schema._meta.fields[field_name], graphene.types.field.Field)
             if rel.has_many(peer_side):
@@ -316,7 +322,7 @@ class GraphQLExtendSchemaRelationship(TestCase):
 
         # Relationships not on VLAN
         for rel in [self.o2o_1, self.o2os_1]:
-            field_name = f"rel_{str_to_var_name(rel.slug)}"
+            field_name = f"rel_{str_to_var_name(rel.key)}"
             self.assertNotIn(field_name, schema._meta.fields.keys())
 
     @override_settings(GRAPHQL_RELATIONSHIP_PREFIX="pr")
@@ -330,7 +336,7 @@ class GraphQLExtendSchemaRelationship(TestCase):
             (self.o2o_1, "source"),
             (self.o2os_1, "peer"),
         ]:
-            field_name = f"pr_{str_to_var_name(rel.slug)}"
+            field_name = f"pr_{str_to_var_name(rel.key)}"
             self.assertIn(field_name, schema._meta.fields.keys())
             self.assertIsInstance(schema._meta.fields[field_name], graphene.types.field.Field)
             if rel.has_many(peer_side):
@@ -341,7 +347,7 @@ class GraphQLExtendSchemaRelationship(TestCase):
         # Special handling of same-type non-symmetric relationships
         for rel in [self.o2m_same_type_1]:
             for peer_side in ["source", "destination"]:
-                field_name = f"pr_{str_to_var_name(rel.slug)}_{peer_side}"
+                field_name = f"pr_{str_to_var_name(rel.key)}_{peer_side}"
                 self.assertIn(field_name, schema._meta.fields.keys())
                 self.assertIsInstance(schema._meta.fields[field_name], graphene.types.field.Field)
                 if rel.has_many(peer_side):
@@ -351,7 +357,7 @@ class GraphQLExtendSchemaRelationship(TestCase):
 
         # Relationships not on Location
         for rel in [self.m2m_1, self.m2m_2]:
-            field_name = f"pr_{str_to_var_name(rel.slug)}"
+            field_name = f"pr_{str_to_var_name(rel.key)}"
             self.assertNotIn(field_name, schema._meta.fields.keys())
 
 
@@ -375,37 +381,43 @@ class GraphQLSearchParameters(TestCase):
 class GraphQLAPIPermissionTest(TestCase):
     client_class = NautobotTestClient
 
-    def setUp(self):
+    @classmethod
+    def setUpTestData(cls):
         """Initialize the Database with some datas and multiple users associated with different permissions."""
-        self.groups = (
+        cls.groups = (
             Group.objects.create(name="Group 1"),
             Group.objects.create(name="Group 2"),
         )
 
-        self.users = (
+        cls.users = (
             User.objects.create(username="User 1", is_active=True),
             User.objects.create(username="User 2", is_active=True),
             User.objects.create(username="Super User", is_active=True, is_superuser=True),
             User.objects.create(username="Nobody", is_active=True),
         )
 
-        self.tokens = (
-            Token.objects.create(user=self.users[0], key="0123456789abcdef0123456789abcdef01234567"),
-            Token.objects.create(user=self.users[1], key="abcd456789abcdef0123456789abcdef01234567"),
-            Token.objects.create(user=self.users[2], key="efgh456789abcdef0123456789abcdef01234567"),
-            Token.objects.create(user=self.users[3], key="ijkl456789abcdef0123456789abcdef01234567"),
+        cls.tokens = (
+            Token.objects.create(user=cls.users[0], key="0123456789abcdef0123456789abcdef01234567"),
+            Token.objects.create(user=cls.users[1], key="abcd456789abcdef0123456789abcdef01234567"),
+            Token.objects.create(user=cls.users[2], key="efgh456789abcdef0123456789abcdef01234567"),
+            Token.objects.create(user=cls.users[3], key="ijkl456789abcdef0123456789abcdef01234567"),
         )
 
-        self.clients = [self.client_class(), self.client_class(), self.client_class(), self.client_class()]
-        self.clients[0].credentials(HTTP_AUTHORIZATION=f"Token {self.tokens[0].key}")
-        self.clients[1].credentials(HTTP_AUTHORIZATION=f"Token {self.tokens[1].key}")
-        self.clients[2].credentials(HTTP_AUTHORIZATION=f"Token {self.tokens[2].key}")
-        self.clients[3].credentials(HTTP_AUTHORIZATION=f"Token {self.tokens[3].key}")
+        cls.clients = [cls.client_class(), cls.client_class(), cls.client_class(), cls.client_class()]
+        cls.clients[0].credentials(HTTP_AUTHORIZATION=f"Token {cls.tokens[0].key}")
+        cls.clients[1].credentials(HTTP_AUTHORIZATION=f"Token {cls.tokens[1].key}")
+        cls.clients[2].credentials(HTTP_AUTHORIZATION=f"Token {cls.tokens[2].key}")
+        cls.clients[3].credentials(HTTP_AUTHORIZATION=f"Token {cls.tokens[3].key}")
 
-        self.location_type = LocationType.objects.get(name="Campus")
-        self.locations = (
-            Location.objects.create(name="Location 1", slug="test1", location_type=self.location_type),
-            Location.objects.create(name="Location 2", slug="test2", location_type=self.location_type),
+        cls.location_type = LocationType.objects.get(name="Campus")
+        location_status = Status.objects.get_for_model(Location).first()
+        cls.locations = (
+            Location.objects.create(
+                name="Location 1", slug="test1", location_type=cls.location_type, status=location_status
+            ),
+            Location.objects.create(
+                name="Location 2", slug="test2", location_type=cls.location_type, status=location_status
+            ),
         )
 
         location_object_type = ContentType.objects.get(app_label="dcim", model="location")
@@ -420,8 +432,8 @@ class GraphQLAPIPermissionTest(TestCase):
                 constraints={"location__slug": f"test{i+1}"},
             )
             rack_obj_permission.object_types.add(rack_object_type)
-            rack_obj_permission.groups.add(self.groups[i])
-            rack_obj_permission.users.add(self.users[i])
+            rack_obj_permission.groups.add(cls.groups[i])
+            rack_obj_permission.users.add(cls.users[i])
 
             location_obj_permission = ObjectPermission.objects.create(
                 name=f"Permission Location {i+1}",
@@ -429,21 +441,22 @@ class GraphQLAPIPermissionTest(TestCase):
                 constraints={"slug": f"test{i+1}"},
             )
             location_obj_permission.object_types.add(location_object_type)
-            location_obj_permission.groups.add(self.groups[i])
-            location_obj_permission.users.add(self.users[i])
+            location_obj_permission.groups.add(cls.groups[i])
+            location_obj_permission.users.add(cls.users[i])
 
-        self.rack_grp1 = (
-            Rack.objects.create(name="Rack 1-1", location=self.locations[0]),
-            Rack.objects.create(name="Rack 1-2", location=self.locations[0]),
+        rack_status = Status.objects.get_for_model(Rack).first()
+        cls.rack_grp1 = (
+            Rack.objects.create(name="Rack 1-1", location=cls.locations[0], status=rack_status),
+            Rack.objects.create(name="Rack 1-2", location=cls.locations[0], status=rack_status),
         )
-        self.rack_grp2 = (
-            Rack.objects.create(name="Rack 2-1", location=self.locations[1]),
-            Rack.objects.create(name="Rack 2-2", location=self.locations[1]),
+        cls.rack_grp2 = (
+            Rack.objects.create(name="Rack 2-1", location=cls.locations[1], status=rack_status),
+            Rack.objects.create(name="Rack 2-2", location=cls.locations[1], status=rack_status),
         )
 
-        self.api_url = reverse("graphql-api")
+        cls.api_url = reverse("graphql-api")
 
-        self.get_racks_query = """
+        cls.get_racks_query = """
         query {
             racks {
                 name
@@ -451,7 +464,7 @@ class GraphQLAPIPermissionTest(TestCase):
         }
         """
 
-        self.get_racks_params_query = """
+        cls.get_racks_params_query = """
         query {
             racks(location: "test1") {
                 name
@@ -459,7 +472,7 @@ class GraphQLAPIPermissionTest(TestCase):
         }
         """
 
-        self.get_racks_var_query = """
+        cls.get_racks_var_query = """
         query ($location: [String]) {
             racks(location: $location) {
                 name
@@ -467,7 +480,7 @@ class GraphQLAPIPermissionTest(TestCase):
         }
         """
 
-        self.get_locations_racks_query = """
+        cls.get_locations_racks_query = """
         query {
             locations {
                 name
@@ -478,7 +491,7 @@ class GraphQLAPIPermissionTest(TestCase):
         }
         """
 
-        self.get_rack_query = """
+        cls.get_rack_query = """
         query ($id: ID!) {
             rack (id: $id) {
                 name
@@ -641,13 +654,15 @@ class GraphQLQueryTest(TestCase):
         cls.location2.status = cls.location_statuses[1]
         cls.location1.validated_save()
         cls.location2.validated_save()
-        cls.rack1 = Rack.objects.create(name="Rack 1", location=cls.location1)
-        cls.rack2 = Rack.objects.create(name="Rack 2", location=cls.location2)
+        rack_statuses = Status.objects.get_for_model(Rack)
+        cls.rack1 = Rack.objects.create(name="Rack 1", location=cls.location1, status=rack_statuses[0])
+        cls.rack2 = Rack.objects.create(name="Rack 2", location=cls.location2, status=rack_statuses[1])
         cls.tenant1 = Tenant.objects.create(name="Tenant 1")
         cls.tenant2 = Tenant.objects.create(name="Tenant 2")
 
-        cls.vlan1 = VLAN.objects.create(name="VLAN 1", vid=100, location=cls.location1)
-        cls.vlan2 = VLAN.objects.create(name="VLAN 2", vid=200, location=cls.location2)
+        vlan_statuses = Status.objects.get_for_model(VLAN)
+        cls.vlan1 = VLAN.objects.create(name="VLAN 1", vid=100, location=cls.location1, status=vlan_statuses[0])
+        cls.vlan2 = VLAN.objects.create(name="VLAN 2", vid=200, location=cls.location2, status=vlan_statuses[1])
 
         cls.location1_power_panels = [
             PowerPanel.objects.create(name="location1-powerpanel1", location=cls.location1),
@@ -758,6 +773,7 @@ class GraphQLQueryTest(TestCase):
             ),
         ]
 
+        interface_status = Status.objects.get_for_model(Interface).first()
         cls.interface11 = Interface.objects.create(
             name="Int1",
             type=InterfaceTypeChoices.TYPE_VIRTUAL,
@@ -765,15 +781,20 @@ class GraphQLQueryTest(TestCase):
             mac_address="00:11:11:11:11:11",
             mode=InterfaceModeChoices.MODE_ACCESS,
             untagged_vlan=cls.vlan1,
+            status=interface_status,
         )
         cls.interface12 = Interface.objects.create(
             name="Int2",
             type=InterfaceTypeChoices.TYPE_VIRTUAL,
             device=cls.device1,
+            status=interface_status,
         )
         cls.ip_statuses = list(Status.objects.get_for_model(IPAddress))[:2]
+        cls.prefix_statuses = list(Status.objects.get_for_model(Prefix))[:2]
         cls.namespace = Namespace.objects.first()
-        cls.prefix1 = Prefix.objects.create(prefix="10.0.1.0/24", namespace=cls.namespace)
+        cls.prefix1 = Prefix.objects.create(
+            prefix="10.0.1.0/24", namespace=cls.namespace, status=cls.prefix_statuses[0]
+        )
         cls.ipaddr1 = IPAddress.objects.create(
             address="10.0.1.1/24", namespace=cls.namespace, status=cls.ip_statuses[0]
         )
@@ -796,11 +817,18 @@ class GraphQLQueryTest(TestCase):
             device=cls.device2,
             untagged_vlan=cls.vlan2,
             mode=InterfaceModeChoices.MODE_ACCESS,
+            status=interface_status,
         )
         cls.interface22 = Interface.objects.create(
-            name="Int2", type=InterfaceTypeChoices.TYPE_1GE_FIXED, device=cls.device2, mac_address="00:12:12:12:12:12"
+            name="Int2",
+            type=InterfaceTypeChoices.TYPE_1GE_FIXED,
+            device=cls.device2,
+            mac_address="00:12:12:12:12:12",
+            status=interface_status,
+        )
+        cls.prefix2 = Prefix.objects.create(
+            prefix="10.0.2.0/24", namespace=cls.namespace, status=cls.prefix_statuses[1]
         )
-        cls.prefix2 = Prefix.objects.create(prefix="10.0.2.0/24", namespace=cls.namespace)
         cls.ipaddr2 = IPAddress.objects.create(
             address="10.0.2.1/30", namespace=cls.namespace, status=cls.ip_statuses[1]
         )
@@ -815,7 +843,7 @@ class GraphQLQueryTest(TestCase):
         )
 
         cls.interface31 = Interface.objects.create(
-            name="Int1", type=InterfaceTypeChoices.TYPE_VIRTUAL, device=cls.device3
+            name="Int1", type=InterfaceTypeChoices.TYPE_VIRTUAL, device=cls.device3, status=interface_status
         )
         cls.interface31 = Interface.objects.create(
             name="Mgmt1",
@@ -823,6 +851,7 @@ class GraphQLQueryTest(TestCase):
             device=cls.device3,
             mgmt_only=True,
             enabled=False,
+            status=interface_status,
         )
 
         cable_statuses = Status.objects.get_for_model(Cable)
@@ -866,59 +895,63 @@ class GraphQLQueryTest(TestCase):
             cluster=cluster,
             status=Status.objects.get_for_model(VirtualMachine)[0],
         )
+        vmintf_status = Status.objects.get_for_model(VMInterface).first()
         cls.vminterface = VMInterface.objects.create(
             virtual_machine=cls.virtualmachine,
             name="eth0",
+            status=vmintf_status,
+        )
+        cls.vmprefix = Prefix.objects.create(
+            prefix="1.1.1.0/24", namespace=cls.namespace, status=cls.prefix_statuses[0]
         )
-        cls.vmprefix = Prefix.objects.create(prefix="1.1.1.0/24", namespace=cls.namespace)
         cls.vmipaddr = IPAddress.objects.create(
             address="1.1.1.1/32", namespace=cls.namespace, status=cls.ip_statuses[0]
         )
         cls.vminterface.add_ip_addresses(cls.vmipaddr)
 
         cls.relationship_o2o_1 = Relationship(
-            name="Device to VirtualMachine",
-            slug="device-to-vm",
+            label="Device to VirtualMachine",
+            key="device_to_vm",
             source_type=ContentType.objects.get_for_model(Device),
             destination_type=ContentType.objects.get_for_model(VirtualMachine),
             type="one-to-one",
         )
-        # cls.relationship_o2o_1.validated_save()
+        cls.relationship_o2o_1.validated_save()
 
         cls.ro2o_assoc_1 = RelationshipAssociation(
             relationship=cls.relationship_o2o_1,
             source=cls.device1,
             destination=cls.virtualmachine,
         )
-        # cls.ro2o_assoc_1.validated_save()
+        cls.ro2o_assoc_1.validated_save()
 
         cls.relationship_m2ms_1 = Relationship(
-            name="Device Group",
-            slug="device-group",
+            label="Device Group",
+            key="device_group",
             source_type=ContentType.objects.get_for_model(Device),
             destination_type=ContentType.objects.get_for_model(Device),
             type="symmetric-many-to-many",
         )
-        # cls.relationship_m2ms_1.validated_save()
+        cls.relationship_m2ms_1.validated_save()
 
         cls.rm2ms_assoc_1 = RelationshipAssociation(
             relationship=cls.relationship_m2ms_1,
             source=cls.device1,
             destination=cls.device2,
         )
-        # cls.rm2ms_assoc_1.validated_save()
+        cls.rm2ms_assoc_1.validated_save()
         cls.rm2ms_assoc_2 = RelationshipAssociation(
             relationship=cls.relationship_m2ms_1,
             source=cls.device2,
             destination=cls.device3,
         )
-        # cls.rm2ms_assoc_2.validated_save()
+        cls.rm2ms_assoc_2.validated_save()
         cls.rm2ms_assoc_3 = RelationshipAssociation(
             relationship=cls.relationship_m2ms_1,
             source=cls.device3,
             destination=cls.device1,
         )
-        # cls.rm2ms_assoc_3.validated_save()
+        cls.rm2ms_assoc_3.validated_save()
 
         cls.backend = get_default_backend()
         cls.schema = graphene_settings.SCHEMA
@@ -1352,19 +1385,19 @@ query {
             ),
             (
                 "mask_length: 24",
-                IPAddress.objects.filter(prefix_length=24).count(),
+                IPAddress.objects.filter(mask_length=24).count(),
             ),
             (
                 "mask_length: 30",
-                IPAddress.objects.filter(prefix_length=30).count(),
+                IPAddress.objects.filter(mask_length=30).count(),
             ),
             (
                 "mask_length: 32",
-                IPAddress.objects.filter(prefix_length=32).count(),
+                IPAddress.objects.filter(mask_length=32).count(),
             ),
             (
                 "mask_length: 28",
-                IPAddress.objects.filter(prefix_length=28).count(),
+                IPAddress.objects.filter(mask_length=28).count(),
             ),
             (
                 'parent: "10.0.0.0/16"',

nautobot/core/tests/test_logging.py

@@ -17,6 +17,10 @@ class LoggingUtilitiesTest(testing.TestCase):
             "I use username FOO and password BAR to log in as https://FOO:BAR@example.com",
             "I use username (redacted) and password (redacted) to log in as https://(redacted)@example.com",
         ),
+        ("Password is1234", "Password (redacted)"),
+        ("Password: is1234", "Password: (redacted)"),
+        ("Password is: is1234", "Password is: (redacted)"),
+        ("Password is is1234", "Password is (redacted)"),
     )
 
     def test_sanitize_default_coverage(self):

nautobot/core/tests/test_managers.py

@@ -1,6 +1,7 @@
 from django.test import TestCase
 
 from nautobot.dcim import models
+from nautobot.extras import models as extras_models
 
 
 class NaturalOrderByManagerTest(TestCase):
@@ -15,7 +16,8 @@ class NaturalOrderByManagerTest(TestCase):
         # Create the Racks
         location_type = models.LocationType.objects.get(name="Campus")
         location = models.Location.objects.filter(location_type=location_type).first()
-        models.Rack.objects.bulk_create(models.Rack(name=name, location=location) for name in names)
+        status = extras_models.Status.objects.get_for_model(models.Rack).first()
+        models.Rack.objects.bulk_create(models.Rack(name=name, location=location, status=status) for name in names)
         # Validate forward ordering
         self.assertEqual(names, list(models.Rack.objects.filter(name__in=names).values_list("name", flat=True)))
 

nautobot/core/tests/test_models.py

@@ -1,4 +1,5 @@
 from django.core.exceptions import ValidationError
+from django.test.utils import isolate_apps
 
 from nautobot.core.models import BaseModel
 from nautobot.core.models.utils import construct_natural_key_slug, deconstruct_natural_key_slug
@@ -6,6 +7,7 @@ from nautobot.core.testing import TestCase
 from nautobot.dcim.models import DeviceType, Manufacturer
 
 
+@isolate_apps("nautobot.core.tests")
 class BaseModelTest(TestCase):
     class FakeBaseModel(BaseModel):
         def clean(self):

nautobot/core/tests/test_paginator.py

@@ -9,6 +9,7 @@ from django.urls import reverse
 from nautobot.core import testing
 from nautobot.core.views import paginator
 from nautobot.dcim import models
+from nautobot.extras import models as extras_models
 
 
 class PaginatorTestCase(testing.TestCase):
@@ -52,8 +53,9 @@ class PaginatorTestCase(testing.TestCase):
     def test_enforce_max_page_size(self):
         """Request an object list view and assert that the MAX_PAGE_SIZE setting is enforced"""
         location_type = models.LocationType.objects.get(name="Campus")
+        status = extras_models.Status.objects.get_for_model(models.Location).first()
         models.Location.objects.bulk_create(
-            [models.Location(name=f"TestLocation{x}", location_type=location_type) for x in range(20)]
+            [models.Location(name=f"TestLocation{x}", location_type=location_type, status=status) for x in range(20)]
         )
         url = reverse("dcim:location_list")
         self.add_permissions("dcim.view_location")

nautobot/core/tests/test_releases.py

@@ -3,8 +3,8 @@ from logging import ERROR
 from unittest.mock import Mock, patch
 
 import requests
-from cacheops import CacheMiss, RedisCache
 from django.conf import settings
+from django.core.cache import cache
 from django.test import SimpleTestCase, override_settings
 from packaging import version
 from requests import Response
@@ -67,10 +67,10 @@ def unsuccessful_github_response(url, *_args, **_kwargs):
 )
 class GetReleasesTestCase(SimpleTestCase):
     @patch.object(requests, "get")
-    @patch.object(RedisCache, "set")
-    @patch.object(RedisCache, "get")
+    @patch.object(cache, "set")
+    @patch.object(cache, "get")
     def test_pre_releases(self, mock_cache_get: Mock, mock_cache_set: Mock, mock_request_get: Mock):
-        mock_cache_get.side_effect = CacheMiss()
+        mock_cache_get.return_value = None
         mock_request_get.side_effect = successful_github_response
 
         releases = get_releases(pre_releases=True)
@@ -108,10 +108,10 @@ class GetReleasesTestCase(SimpleTestCase):
         mock_cache_set.assert_called_once_with("latest_release", (expected_version, expected_url), 160876)
 
     @patch.object(requests, "get")
-    @patch.object(RedisCache, "set")
-    @patch.object(RedisCache, "get")
+    @patch.object(cache, "set")
+    @patch.object(cache, "get")
     def test_no_pre_releases(self, mock_cache_get: Mock, mock_cache_set: Mock, mock_request_get: Mock):
-        mock_cache_get.side_effect = CacheMiss()
+        mock_cache_get.return_value = None
         mock_request_get.side_effect = successful_github_response
 
         releases = get_releases(pre_releases=False)
@@ -145,10 +145,10 @@ class GetReleasesTestCase(SimpleTestCase):
         mock_cache_set.assert_called_once_with("latest_release", (expected_version, expected_url), 160876)
 
     @patch.object(requests, "get")
-    @patch.object(RedisCache, "set")
-    @patch.object(RedisCache, "get")
+    @patch.object(cache, "set")
+    @patch.object(cache, "get")
     def test_failed_request(self, mock_cache_get: Mock, mock_cache_set: Mock, mock_request_get: Mock):
-        mock_cache_get.side_effect = CacheMiss()
+        mock_cache_get.return_value = None
         mock_request_get.side_effect = unsuccessful_github_response
 
         with self.assertLogs(level=ERROR) as cm:
@@ -175,8 +175,8 @@ class GetReleasesTestCase(SimpleTestCase):
         mock_cache_set.assert_called_once_with("latest_release_no_retry", "https://localhost/unittest/releases", 900)
 
     @patch.object(requests, "get")
-    @patch.object(RedisCache, "set")
-    @patch.object(RedisCache, "get")
+    @patch.object(cache, "set")
+    @patch.object(cache, "get")
     def test_blocked_retry(self, mock_cache_get: Mock, mock_cache_set: Mock, mock_request_get: Mock):
         mock_cache_get.return_value = "https://localhost/unittest/releases"
         mock_request_get.side_effect = successful_github_response

nautobot/core/tests/test_templatetags_helpers.py

@@ -27,24 +27,24 @@ class NautobotTemplatetagsHelperTest(TestCase):
         location.description = ""
         location.save()
         self.assertEqual(
-            helpers.hyperlinked_object(location), f'<a href="/dcim/locations/{location.slug}/">{location.name}</a>'
+            helpers.hyperlinked_object(location), f'<a href="/dcim/locations/{location.pk}/">{location.name}</a>'
         )
         # An object with get_absolute_url and a description gives a titled hyperlink
         location.description = "An important location"
         location.save()
         self.assertEqual(
             helpers.hyperlinked_object(location),
-            f'<a href="/dcim/locations/{location.slug}/" title="An important location">{location.name}</a>',
+            f'<a href="/dcim/locations/{location.pk}/" title="An important location">{location.name}</a>',
         )
         # Optionally you can request a field other than the object's display string
         self.assertEqual(
             helpers.hyperlinked_object(location, "slug"),
-            f'<a href="/dcim/locations/{location.slug}/" title="An important location">{location.slug}</a>',
+            f'<a href="/dcim/locations/{location.pk}/" title="An important location">{location.slug}</a>',
         )
         # If you request a nonexistent field, it defaults to the string representation
         self.assertEqual(
             helpers.hyperlinked_object(location, "foo"),
-            f'<a href="/dcim/locations/{location.slug}/" title="An important location">{location!s}</a>',
+            f'<a href="/dcim/locations/{location.pk}/" title="An important location">{location!s}</a>',
         )
 
     def test_placeholder(self):