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

nautobot/core/tests/test_graphql.py

@@ -66,10 +66,11 @@ from nautobot.extras.models import (
     Status,
     Webhook,
 )
-from nautobot.ipam.models import IPAddress, VLAN
+from nautobot.ipam.models import IPAddress, VLAN, Namespace, Prefix
 from nautobot.users.models import ObjectPermission, Token
 from nautobot.tenancy.models import Tenant
-from nautobot.virtualization.models import Cluster, ClusterType, VirtualMachine, VMInterface
+from nautobot.virtualization.factory import ClusterTypeFactory
+from nautobot.virtualization.models import Cluster, VirtualMachine, VMInterface
 
 # Use the proper swappable User model
 User = get_user_model()
@@ -78,15 +79,20 @@ User = get_user_model()
 class GraphQLTestCase(TestCase):
     def setUp(self):
         self.user = create_test_user("graphql_testuser")
-        GraphQLQuery.objects.create(name="GQL 1", slug="gql-1", query="{ query: locations {name} }")
-        GraphQLQuery.objects.create(
-            name="GQL 2", slug="gql-2", query="query ($name: [String!]) { locations(name:$name) {name} }"
-        )
+        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=["*"])
@@ -109,17 +115,16 @@ class GraphQLTestCase(TestCase):
             execute_query(query, user=self.user).to_dict()
 
     def test_execute_saved_query(self):
-        resp = execute_saved_query("gql-1", user=self.user).to_dict()
+        resp = execute_saved_query("GQL 1", user=self.user).to_dict()
         self.assertFalse(resp["data"].get("error"))
 
     def test_execute_saved_query_with_variable(self):
-        resp = execute_saved_query("gql-2", user=self.user, variables={"name": "location-1"}).to_dict()
+        resp = execute_saved_query("GQL 2", user=self.user, variables={"name": "location-1"}).to_dict()
         self.assertFalse(resp["data"].get("error"))
 
 
 class GraphQLUtilsTestCase(TestCase):
     def test_str_to_var_name(self):
-
         self.assertEqual(str_to_var_name("IP Addresses"), "ip_addresses")
         self.assertEqual(str_to_var_name("My New VAR"), "my_new_var")
         self.assertEqual(str_to_var_name("My-VAR"), "my_var")
@@ -127,14 +132,12 @@ class GraphQLUtilsTestCase(TestCase):
 
 class GraphQLGenerateSchemaTypeTestCase(TestCase):
     def test_model_w_filterset(self):
-
         schema = generate_schema_type(app_name="dcim", model=Device)
         self.assertEqual(schema.__bases__[0], DjangoObjectType)
         self.assertEqual(schema._meta.model, Device)
         self.assertEqual(schema._meta.filterset_class, DeviceFilterSet)
 
     def test_model_wo_filterset(self):
-
         schema = generate_schema_type(app_name="wrong_app", model=ChangeLoggedModel)
         self.assertEqual(schema.__bases__[0], DjangoObjectType)
         self.assertEqual(schema._meta.model, ChangeLoggedModel)
@@ -143,7 +146,6 @@ class GraphQLGenerateSchemaTypeTestCase(TestCase):
 
 class GraphQLExtendSchemaType(TestCase):
     def setUp(self):
-
         self.datas = (
             {"field_name": "my_text", "field_type": CustomFieldTypeChoices.TYPE_TEXT},
             {
@@ -181,7 +183,6 @@ class GraphQLExtendSchemaType(TestCase):
 
     @override_settings(GRAPHQL_CUSTOM_FIELD_PREFIX="pr")
     def test_extend_custom_field_w_prefix(self):
-
         schema = extend_schema_type_custom_field(self.schema, Location)
 
         for data in self.datas:
@@ -190,7 +191,6 @@ class GraphQLExtendSchemaType(TestCase):
 
     @override_settings(GRAPHQL_CUSTOM_FIELD_PREFIX="")
     def test_extend_custom_field_wo_prefix(self):
-
         schema = extend_schema_type_custom_field(self.schema, Location)
 
         for data in self.datas:
@@ -199,7 +199,6 @@ class GraphQLExtendSchemaType(TestCase):
 
     @override_settings(GRAPHQL_CUSTOM_FIELD_PREFIX=None)
     def test_extend_custom_field_prefix_none(self):
-
         schema = extend_schema_type_custom_field(self.schema, Location)
 
         for data in self.datas:
@@ -207,19 +206,16 @@ class GraphQLExtendSchemaType(TestCase):
             self.assertIn(field_name, schema._meta.fields.keys())
 
     def test_extend_tags_enabled(self):
-
         schema = extend_schema_type_tags(self.schema, Location)
 
         self.assertTrue(hasattr(schema, "resolve_tags"))
         self.assertIsInstance(getattr(schema, "resolve_tags"), types.FunctionType)
 
     def test_extend_config_context(self):
-
         schema = extend_schema_type_config_context(DeviceTypeGraphQL, Device)
         self.assertIn("config_context", schema._meta.fields.keys())
 
     def test_extend_schema_device(self):
-
         # The below *will* log an error as DeviceTypeGraphQL has already been extended automatically...?
         schema = extend_schema_type(DeviceTypeGraphQL)
         self.assertIn("config_context", schema._meta.fields.keys())
@@ -227,14 +223,12 @@ class GraphQLExtendSchemaType(TestCase):
         self.assertIsInstance(getattr(schema, "resolve_tags"), types.FunctionType)
 
     def test_extend_schema_location(self):
-
         schema = extend_schema_type(self.schema)
         self.assertNotIn("config_context", schema._meta.fields.keys())
         self.assertTrue(hasattr(schema, "resolve_tags"))
         self.assertIsInstance(getattr(schema, "resolve_tags"), types.FunctionType)
 
     def test_extend_schema_null_field_choices(self):
-
         schema = extend_schema_type_null_field_choice(self.schema, Interface)
 
         self.assertTrue(hasattr(schema, "resolve_mode"))
@@ -243,14 +237,13 @@ class GraphQLExtendSchemaType(TestCase):
 
 class GraphQLExtendSchemaRelationship(TestCase):
     def setUp(self):
-
         location_ct = ContentType.objects.get_for_model(Location)
         rack_ct = ContentType.objects.get_for_model(Rack)
         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,
@@ -260,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",
@@ -269,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",
@@ -278,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,
@@ -289,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",
@@ -298,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",
@@ -319,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):
@@ -329,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")
@@ -343,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):
@@ -354,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):
@@ -364,17 +357,15 @@ 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())
 
 
 class GraphQLSearchParameters(TestCase):
     def setUp(self):
-
         self.schema = generate_schema_type(app_name="dcim", model=Location)
 
     def test_search_parameters(self):
-
         fields = LocationFilterSet().filters.keys()
         params = generate_list_search_parameters(self.schema)
         exclude_filters = ["type"]
@@ -390,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")
@@ -435,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}",
@@ -444,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
@@ -466,7 +464,7 @@ class GraphQLAPIPermissionTest(TestCase):
         }
         """
 
-        self.get_racks_params_query = """
+        cls.get_racks_params_query = """
         query {
             racks(location: "test1") {
                 name
@@ -474,7 +472,7 @@ class GraphQLAPIPermissionTest(TestCase):
         }
         """
 
-        self.get_racks_var_query = """
+        cls.get_racks_var_query = """
         query ($location: [String]) {
             racks(location: $location) {
                 name
@@ -482,7 +480,7 @@ class GraphQLAPIPermissionTest(TestCase):
         }
         """
 
-        self.get_locations_racks_query = """
+        cls.get_locations_racks_query = """
         query {
             locations {
                 name
@@ -493,7 +491,7 @@ class GraphQLAPIPermissionTest(TestCase):
         }
         """
 
-        self.get_rack_query = """
+        cls.get_rack_query = """
         query ($id: ID!) {
             rack (id: $id) {
                 name
@@ -656,28 +654,31 @@ 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)
-        cls.tenant1 = Tenant.objects.create(name="Tenant 1", slug="tenant-1")
-        cls.tenant2 = Tenant.objects.create(name="Tenant 2", slug="tenant-2")
+        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),
             PowerPanel.objects.create(name="location1-powerpanel2", location=cls.location1),
             PowerPanel.objects.create(name="location1-powerpanel3", location=cls.location1),
         ]
+        powerfeed_status = Status.objects.get_for_model(PowerFeed).first()
         cls.location1_power_feeds = [
             PowerFeed.objects.create(
                 name="location1-powerfeed1",
-                status=Status.objects.get(name="Active"),
+                status=powerfeed_status,
                 power_panel=cls.location1_power_panels[0],
             ),
             PowerFeed.objects.create(
                 name="location1-powerfeed2",
-                status=Status.objects.get(name="Active"),
+                status=powerfeed_status,
                 power_panel=cls.location1_power_panels[1],
             ),
         ]
@@ -772,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,
@@ -779,14 +781,23 @@ 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.ipaddr1 = IPAddress.objects.create(address="10.0.1.1/24", status=cls.ip_statuses[0])
+        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, status=cls.prefix_statuses[0]
+        )
+        cls.ipaddr1 = IPAddress.objects.create(
+            address="10.0.1.1/24", namespace=cls.namespace, status=cls.ip_statuses[0]
+        )
         cls.interface11.add_ip_addresses(cls.ipaddr1)
 
         cls.device2 = Device.objects.create(
@@ -806,11 +817,21 @@ 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.ipaddr2 = IPAddress.objects.create(
+            address="10.0.2.1/30", namespace=cls.namespace, status=cls.ip_statuses[1]
         )
-        cls.ipaddr2 = IPAddress.objects.create(address="10.0.2.1/30", status=cls.ip_statuses[1])
         cls.interface12.add_ip_addresses(cls.ipaddr2)
 
         cls.device3 = Device.objects.create(
@@ -822,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",
@@ -830,58 +851,67 @@ class GraphQLQueryTest(TestCase):
             device=cls.device3,
             mgmt_only=True,
             enabled=False,
+            status=interface_status,
         )
 
+        cable_statuses = Status.objects.get_for_model(Cable)
         cls.cable1 = Cable.objects.create(
             termination_a=cls.interface11,
             termination_b=cls.interface12,
-            status=Status.objects.get_for_model(Cable)[0],
+            status=cable_statuses[0],
         )
         cls.cable2 = Cable.objects.create(
             termination_a=cls.interface31,
             termination_b=cls.interface21,
-            status=Status.objects.get_for_model(Cable)[1],
+            status=cable_statuses[1],
         )
 
         # Power Cables
         cls.cable3 = Cable.objects.create(
             termination_a=cls.device1_power_ports[0],
             termination_b=cls.upsdevice1_power_outlets[0],
-            status=Status.objects.get(name="Active"),
+            status=cable_statuses[0],
         )
         cls.cable3 = Cable.objects.create(
             termination_a=cls.upsdevice1_power_ports[0],
             termination_b=cls.location1_power_feeds[0],
-            status=Status.objects.get(name="Active"),
+            status=cable_statuses[0],
         )
 
         ConfigContext.objects.create(name="context 1", weight=101, data={"a": 123, "b": 456, "c": 777})
 
-        Provider.objects.create(name="provider 1", slug="provider-1", asn=1)
-        Provider.objects.create(name="provider 2", slug="provider-2", asn=4294967295)
+        Provider.objects.create(name="provider 1", asn=1)
+        Provider.objects.create(name="provider 2", asn=4294967295)
 
         webhook1 = Webhook.objects.create(name="webhook 1", type_delete=True, enabled=False)
         webhook1.content_types.add(ContentType.objects.get_for_model(Device))
         webhook2 = Webhook.objects.create(name="webhook 2", type_update=True, enabled=False)
         webhook2.content_types.add(ContentType.objects.get_for_model(Interface))
 
-        clustertype = ClusterType.objects.create(name="Cluster Type 1", slug="cluster-type-1")
+        clustertype = ClusterTypeFactory.create()
         cluster = Cluster.objects.create(name="Cluster 1", cluster_type=clustertype)
         cls.virtualmachine = VirtualMachine.objects.create(
             name="Virtual Machine 1",
             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.vmipaddr = IPAddress.objects.create(
+            address="1.1.1.1/32", namespace=cls.namespace, status=cls.ip_statuses[0]
         )
-        cls.vmipaddr = IPAddress.objects.create(address="1.1.1.1/32", 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",
@@ -896,8 +926,8 @@ class GraphQLQueryTest(TestCase):
         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",
@@ -927,7 +957,6 @@ class GraphQLQueryTest(TestCase):
         cls.schema = graphene_settings.SCHEMA
 
     def execute_query(self, query, variables=None):
-
         document = self.backend.document_from_string(self.schema, query)
         if variables:
             return document.execute(context_value=self.request, variable_values=variables)
@@ -1004,7 +1033,6 @@ query {
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_query_config_context_and_custom_field_data(self):
-
         query = (
             # pylint: disable=consider-using-f-string
             """
@@ -1163,7 +1191,9 @@ query {
             # Assert GraphQL returned properties match those expected
             self.assertEqual(console_server_port_entry["connected_console_port"], connected_console_port)
 
-    @skip("Works in isolation, fails as part of the overall test suite due to issue #446")
+    @skip(
+        "Works in isolation, fails as part of the overall test suite due to issue #446, also something is broken with content types"
+    )
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_query_relationship_associations(self):
         """Test queries involving relationship associations."""
@@ -1200,7 +1230,6 @@ query {
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_query_device_role_filter(self):
-
         query = (
             # pylint: disable=consider-using-f-string
             """
@@ -1211,7 +1240,7 @@ query {
                     }
                 }
             """
-            % (self.device_role1.slug,)
+            % (self.device_role1.name,)
         )
         result = self.execute_query(query)
 
@@ -1222,7 +1251,6 @@ query {
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_query_with_bad_filter(self):
-
         query = """
             query {
                 devices(role: "EXPECT NO ENTRIES") {
@@ -1238,7 +1266,6 @@ query {
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_query_locations_filter(self):
-
         filters = (
             ('name: "Location-1"', 1),
             ('name: ["Location-1"]', 1),
@@ -1254,15 +1281,15 @@ query {
             (f'id: ["{self.location1.pk}"]', 1),
             (f'id: ["{self.location1.pk}", "{self.location2.pk}"]', 2),
             (
-                f'status: "{self.location_statuses[0].slug}"',
+                f'status: "{self.location_statuses[0].name}"',
                 Location.objects.filter(status=self.location_statuses[0]).count(),
             ),
             (
-                f'status: ["{self.location_statuses[1].slug}"]',
+                f'status: ["{self.location_statuses[1].name}"]',
                 Location.objects.filter(status=self.location_statuses[1]).count(),
             ),
             (
-                f'status: ["{self.location_statuses[0].slug}", "{self.location_statuses[1].slug}"]',
+                f'status: ["{self.location_statuses[0].name}", "{self.location_statuses[1].name}"]',
                 Location.objects.filter(status__in=self.location_statuses[:2]).count(),
             ),
         )
@@ -1276,7 +1303,6 @@ query {
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_query_devices_filter(self):
-
         filterset_class = DeviceFilterSet
         queryset = Device.objects.all()
 
@@ -1296,10 +1322,10 @@ query {
             f'id: "{self.device1.pk}"': _count({"id": [self.device1.pk]}),
             f'id: ["{self.device1.pk}"]': _count({"id": [self.device1.pk]}),
             f'id: ["{self.device1.pk}", "{self.device2.pk}"]': _count({"id": [self.device1.pk, self.device2.pk]}),
-            f'role: "{self.device_role1.slug}"': _count({"role": [self.device_role1.slug]}),
-            f'role: ["{self.device_role1.slug}"]': _count({"role": [self.device_role1.slug]}),
-            f'role: ["{self.device_role1.slug}", "{self.device_role2.slug}"]': _count(
-                {"role": [self.device_role1.slug, self.device_role2.slug]}
+            f'role: "{self.device_role1.name}"': _count({"role": [self.device_role1.name]}),
+            f'role: ["{self.device_role1.name}"]': _count({"role": [self.device_role1.name]}),
+            f'role: ["{self.device_role1.name}", "{self.device_role2.name}"]': _count(
+                {"role": [self.device_role1.name, self.device_role2.name]}
             ),
             f'location: "{self.location1.slug}"': _count({"location": [self.location1.slug]}),
             f'location: ["{self.location1.slug}"]': _count({"location": [self.location1.slug]}),
@@ -1308,10 +1334,10 @@ query {
             ),
             'face: "front"': _count({"face": ["front"]}),
             'face: "rear"': _count({"face": ["rear"]}),
-            f'status: "{self.device_statuses[0].slug}"': _count({"status": [self.device_statuses[0].slug]}),
-            f'status: ["{self.device_statuses[1].slug}"]': _count({"status": [self.device_statuses[1].slug]}),
-            f'status: ["{self.device_statuses[0].slug}", "{self.device_statuses[1].slug}"]': _count(
-                {"status": [self.device_statuses[0].slug, self.device_statuses[1].slug]}
+            f'status: "{self.device_statuses[0].name}"': _count({"status": [self.device_statuses[0].name]}),
+            f'status: ["{self.device_statuses[1].name}"]': _count({"status": [self.device_statuses[1].name]}),
+            f'status: ["{self.device_statuses[0].name}", "{self.device_statuses[1].name}"]': _count(
+                {"status": [self.device_statuses[0].name, self.device_statuses[1].name]}
             ),
             "is_full_depth: true": _count({"is_full_depth": True}),
             "is_full_depth: false": _count({"is_full_depth": False}),
@@ -1336,43 +1362,42 @@ query {
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_query_ip_addresses_filter(self):
-
         filters = (
             (
                 'address: "10.0.1.1"',
                 IPAddress.objects.filter(host="10.0.1.1").count(),
             ),
             (
-                "family: 4",
-                IPAddress.objects.ip_family(4).count(),
+                'ip_version: "4"',  # TODO: should be int, GraphQL bug?
+                IPAddress.objects.filter(ip_version=4).count(),
             ),
             (
-                f'status: "{self.ip_statuses[0].slug}"',
+                f'status: "{self.ip_statuses[0].name}"',
                 IPAddress.objects.filter(status=self.ip_statuses[0]).count(),
             ),
             (
-                f'status: ["{self.ip_statuses[1].slug}"]',
+                f'status: ["{self.ip_statuses[1].name}"]',
                 IPAddress.objects.filter(status=self.ip_statuses[1]).count(),
             ),
             (
-                f'status: ["{self.ip_statuses[0].slug}", "{self.ip_statuses[1].slug}"]',
+                f'status: ["{self.ip_statuses[0].name}", "{self.ip_statuses[1].name}"]',
                 IPAddress.objects.filter(status__in=[self.ip_statuses[0], self.ip_statuses[1]]).count(),
             ),
             (
                 "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"',
@@ -1410,7 +1435,7 @@ query {
                 virtual_machine { name }
             }
         }
-        family
+        ip_version
         interface { name }
         vminterface { name }
     }
@@ -1423,7 +1448,7 @@ query {
                 entry["address"], (str(self.ipaddr1.address), str(self.ipaddr2.address), str(self.vmipaddr.address))
             )
             self.assertIn("assigned_object", entry)
-            self.assertIn(entry["family"], (4, 6))
+            self.assertIn(entry["ip_version"], (4, 6))
             if entry["address"] == str(self.vmipaddr.address):
                 self.assertEqual(entry["assigned_object"]["name"], self.vminterface.name)
                 self.assertEqual(entry["vminterface"]["name"], self.vminterface.name)
@@ -1441,7 +1466,6 @@ query {
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_query_cables_filter(self):
-
         filters = (
             (f'device_id: "{self.device1.id}"', 2),
             ('device: "Device 3"', 1),
@@ -1453,8 +1477,8 @@ query {
             (f'location: "{self.location2.slug}"', 1),
             (f'location: ["{self.location1.slug}", "{self.location2.slug}"]', 4),
             (f'tenant_id: "{self.tenant1.id}"', 3),
-            ('tenant: "tenant-2"', 1),
-            ('tenant: ["tenant-1", "tenant-2"]', 4),
+            ('tenant: "Tenant 2"', 1),
+            ('tenant: ["Tenant 1", "Tenant 2"]', 4),
         )
 
         for filterv, nbr_expected_results in filters:
@@ -1899,7 +1923,6 @@ query {
 
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_query_interface_pagination(self):
-
         query_pagination = """\
 query {
     interfaces(limit: 2, offset: 3) {