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

nautobot/extras/tests/test_dynamicgroups.py

@@ -46,35 +46,33 @@ class DynamicGroupTestBase(TestCase):
         cls.dynamicgroup_ct = ContentType.objects.get_for_model(DynamicGroup)
         cls.lt = LocationType.objects.get(name="Campus")
 
+        loc_status = Status.objects.get_for_model(Location).first()
         cls.locations = [
-            Location.objects.create(name="Location 1", slug="location-1", location_type=cls.lt),
-            Location.objects.create(name="Location 2", slug="location-2", location_type=cls.lt),
-            Location.objects.create(name="Location 3", slug="location-3", location_type=cls.lt),
-            Location.objects.create(name="Location 4", slug="location-4", location_type=cls.lt),
+            Location.objects.create(name="Location 1", slug="location-1", location_type=cls.lt, status=loc_status),
+            Location.objects.create(name="Location 2", slug="location-2", location_type=cls.lt, status=loc_status),
+            Location.objects.create(name="Location 3", slug="location-3", location_type=cls.lt, status=loc_status),
+            Location.objects.create(name="Location 4", slug="location-4", location_type=cls.lt, status=loc_status),
         ]
 
-        cls.manufacturer = Manufacturer.objects.create(name="Manufacturer 1", slug="manufacturer-1")
-        cls.device_type = DeviceType.objects.create(
-            manufacturer=cls.manufacturer,
-            model="device Type 1",
-            slug="device-type-1",
-        )
+        cls.manufacturer = Manufacturer.objects.first()
+        cls.device_type = DeviceType.objects.first()
         cls.device_role = Role.objects.get_for_model(Device).first()
-        cls.status_active = Status.objects.get_for_model(Device).get(slug="active")
-        cls.status_planned = Status.objects.get_for_model(Device).get(slug="planned")
-        cls.status_staged = Status.objects.get_for_model(Device).get(slug="staged")
+        statuses = Status.objects.get_for_model(Device)
+        cls.status_1 = statuses[0]
+        cls.status_2 = statuses[1]
+        cls.status_3 = statuses[2]
 
         cls.devices = [
             Device.objects.create(
                 name="device-location-1",
-                status=cls.status_active,
+                status=cls.status_1,
                 role=cls.device_role,
                 device_type=cls.device_type,
                 location=cls.locations[0],
             ),
             Device.objects.create(
                 name="device-location-2",
-                status=cls.status_active,
+                status=cls.status_1,
                 role=cls.device_role,
                 device_type=cls.device_type,
                 serial="abc123",
@@ -82,14 +80,14 @@ class DynamicGroupTestBase(TestCase):
             ),
             Device.objects.create(
                 name="device-location-3",
-                status=cls.status_planned,
+                status=cls.status_2,
                 role=cls.device_role,
                 device_type=cls.device_type,
                 location=cls.locations[2],
             ),
             Device.objects.create(
                 name="device-location-4",
-                status=cls.status_staged,
+                status=cls.status_3,
                 role=cls.device_role,
                 device_type=cls.device_type,
                 location=cls.locations[3],
@@ -99,7 +97,6 @@ class DynamicGroupTestBase(TestCase):
         cls.groups = [
             DynamicGroup.objects.create(
                 name="Parent",
-                slug="parent",
                 description="The parent group with no filter",
                 filter={},
                 content_type=cls.device_ct,
@@ -107,7 +104,6 @@ class DynamicGroupTestBase(TestCase):
             # Location-1 only
             DynamicGroup.objects.create(
                 name="First Child",
-                slug="first-child",
                 description="The first child group",
                 filter={"location": ["location-1"]},
                 content_type=cls.device_ct,
@@ -115,7 +111,6 @@ class DynamicGroupTestBase(TestCase):
             # Location-2 only
             DynamicGroup.objects.create(
                 name="Second Child",
-                slug="second-child",
                 description="A second child group",
                 filter={"location": ["location-3"]},
                 content_type=cls.device_ct,
@@ -123,7 +118,6 @@ class DynamicGroupTestBase(TestCase):
             # Empty filter to use for testing nesting.
             DynamicGroup.objects.create(
                 name="Third Child",
-                slug="third-child",
                 description="A third child group with a child of its own",
                 filter={},
                 content_type=cls.device_ct,
@@ -131,22 +125,19 @@ class DynamicGroupTestBase(TestCase):
             # Nested child of third-child to test ancestors/descendants
             DynamicGroup.objects.create(
                 name="Nested Child",
-                slug="nested-child",
                 description="This will be the child of third-child",
-                filter={"status": ["active"]},
+                filter={"status": [statuses[0].name]},
                 content_type=cls.device_ct,
             ),
             # No matches (bogus/invalid name match)
             DynamicGroup.objects.create(
                 name="Invalid Filter",
-                slug="invalid-filter",
                 description="A group with a non-matching filter",
                 filter={"name": ["bogus"]},
                 content_type=cls.device_ct,
             ),
             DynamicGroup.objects.create(
                 name="MultiValueCharFilter",
-                slug="multivaluecharfilter",
                 description="A group with a multivaluechar filter",
                 filter={"name": ["device-1", "device-2", "device-3"]},
                 content_type=cls.device_ct,
@@ -275,7 +266,7 @@ class DynamicGroupModelTest(DynamicGroupTestBase):  # TODO: BaseModelTestCase mi
         # Grab some values we'll used to setup the test case.
         device1 = self.devices[0]
         device2 = self.devices[1]
-        status = Status.objects.get(slug="active")
+        status = Status.objects.get_for_model(Location).first()
 
         # Create two LocationTypes (My Region > My Site)
         loc_type_region = LocationType.objects.create(name="My Region", slug="my-region")
@@ -301,7 +292,6 @@ class DynamicGroupModelTest(DynamicGroupTestBase):  # TODO: BaseModelTestCase mi
         # Create the Dynamic Group filtering on Location A
         group = DynamicGroup.objects.create(
             name="Devices Location",
-            slug="devices-location",
             content_type=self.device_ct,
             filter={"location": ["location-a"]},
         )
@@ -317,7 +307,6 @@ class DynamicGroupModelTest(DynamicGroupTestBase):  # TODO: BaseModelTestCase mi
         # the same number of members.
         parent_group = DynamicGroup.objects.create(
             name="Parent of Devices Location",
-            slug="parent-devices-location",
             content_type=self.device_ct,
             filter={},
         )
@@ -370,7 +359,7 @@ class DynamicGroupModelTest(DynamicGroupTestBase):  # TODO: BaseModelTestCase mi
     def test_model(self):
         """Test `DynamicGroup.model`."""
         # New instances should not have a model unless `content_type` is set.
-        new_group = DynamicGroup(name="Unsaved Group", slug="unsaved-group")
+        new_group = DynamicGroup(name="Unsaved Group")
         self.assertIsNone(new_group.model)
 
         # Setting the content_type will now allow `.model` to be accessed.
@@ -380,7 +369,7 @@ class DynamicGroupModelTest(DynamicGroupTestBase):  # TODO: BaseModelTestCase mi
     def test_set_object_classes(self):
         """Test `DynamicGroup._set_object_classes()`."""
         # New instances should fail to map until `content_type` is set.
-        new_group = DynamicGroup(name="Unsaved Group", slug="unsaved-group")
+        new_group = DynamicGroup(name="Unsaved Group")
         objects_mapped = new_group._set_object_classes(new_group.model)
         self.assertFalse(objects_mapped)
 
@@ -401,7 +390,7 @@ class DynamicGroupModelTest(DynamicGroupTestBase):  # TODO: BaseModelTestCase mi
         # First assert that a basic group with no children, then a group with children, will always
         # link to the members tab on the detail view.
         for group in [self.first_child, self.parent]:
-            detail_url = reverse("extras:dynamicgroup", kwargs={"slug": group.slug})
+            detail_url = reverse("extras:dynamicgroup", kwargs={"pk": group.pk})
             params = "tab=members"
             url = f"{detail_url}?{params}"
             self.assertEqual(group.get_group_members_url(), url)
@@ -494,7 +483,7 @@ class DynamicGroupModelTest(DynamicGroupTestBase):  # TODO: BaseModelTestCase mi
 
         """
         pfx_content_type = ContentType.objects.get_for_model(Prefix)
-        group = DynamicGroup(name="pfx", slug="pfx", content_type=pfx_content_type)
+        group = DynamicGroup(name="pfx", content_type=pfx_content_type)
         filterset = group.filterset_class()
         fields = group._map_filter_fields
 
@@ -512,7 +501,7 @@ class DynamicGroupModelTest(DynamicGroupTestBase):  # TODO: BaseModelTestCase mi
     def test_get_filter_fields(self):
         """Test `DynamicGroup.get_filter_fields()`."""
         # New instances should return {} `content_type` is set.
-        new_group = DynamicGroup(name="Unsaved Group", slug="unsaved-group")
+        new_group = DynamicGroup(name="Unsaved Group")
         new_filter_fields = new_group.get_filter_fields()
         self.assertEqual(new_filter_fields, {})
 
@@ -582,7 +571,7 @@ class DynamicGroupModelTest(DynamicGroupTestBase):  # TODO: BaseModelTestCase mi
             operator=DynamicGroupOperatorChoices.OPERATOR_DIFFERENCE,
             weight=10,
         )
-        self.assertTrue(self.parent.children.filter(slug=self.invalid_filter.slug).exists())
+        self.assertTrue(self.parent.children.filter(name=self.invalid_filter.name).exists())
 
     def test_clean_child_validation(self):
         """Test various ways in which adding a child group should fail."""
@@ -602,16 +591,13 @@ class DynamicGroupModelTest(DynamicGroupTestBase):  # TODO: BaseModelTestCase mi
         with self.assertRaises(ValidationError):
             parent.children.add(
                 child,
-                through_defaults=dict(
-                    operator=DynamicGroupOperatorChoices.OPERATOR_DIFFERENCE,
-                    weight=10,
-                ),
+                through_defaults={"operator": DynamicGroupOperatorChoices.OPERATOR_DIFFERENCE, "weight": 10},
             )
 
     def test_remove_child(self):
         """Test `DynamicGroup.remove_child()`."""
         self.parent.remove_child(self.third_child)
-        self.assertFalse(self.parent.children.filter(slug=self.third_child.slug).exists())
+        self.assertFalse(self.parent.children.filter(name=self.third_child.name).exists())
 
     def test_generate_query_for_filter(self):
         """Test `DynamicGroup.generate_query_for_filter()`."""
@@ -643,7 +629,7 @@ class DynamicGroupModelTest(DynamicGroupTestBase):  # TODO: BaseModelTestCase mi
         # test a regression w/ nested slug-related values such as `DeviceFilterSet.macufacturer` which
         # filters on `device_type__manufacturer`.
         manufacturer = Manufacturer.objects.first()
-        nested_value = [manufacturer.slug]
+        nested_value = [manufacturer.name]
         group.set_filter({"manufacturer": nested_value})
         group.validated_save()
 
@@ -652,7 +638,7 @@ class DynamicGroupModelTest(DynamicGroupTestBase):  # TODO: BaseModelTestCase mi
         # is automatically used to get the related model name without failing.
         nested_query = group.generate_query_for_filter(filter_field=fs.filters["manufacturer"], value=nested_value)
         nested_qs = queryset.filter(nested_query)
-        parent_qs = Device.objects.filter(device_type__manufacturer__slug__in=nested_value)
+        parent_qs = Device.objects.filter(device_type__manufacturer__name__in=nested_value)
         self.assertQuerySetEqual(nested_qs, parent_qs)
 
     def test_generate_query_for_group(self):
@@ -686,20 +672,20 @@ class DynamicGroupModelTest(DynamicGroupTestBase):  # TODO: BaseModelTestCase mi
 
     def test_get_ancestors(self):
         """Test `DynamicGroup.get_ancestors()`."""
-        expected = ["third-child", "parent"]
-        ancestors = [a.slug for a in self.nested_child.get_ancestors()]
+        expected = ["Third Child", "Parent"]
+        ancestors = [a.name for a in self.nested_child.get_ancestors()]
         self.assertEqual(ancestors, expected)
 
     def test_get_descendants(self):
         """Test `DynamicGroup.get_descendants()`."""
-        expected = ["first-child", "second-child", "third-child", "nested-child"]
-        descendants = [d.slug for d in self.parent.get_descendants()]
+        expected = ["First Child", "Second Child", "Third Child", "Nested Child"]
+        descendants = [d.name for d in self.parent.get_descendants()]
         self.assertEqual(descendants, expected)
 
     def test_get_siblings(self):
         """Test `DynamicGroup.get_siblings()`."""
-        expected = ["first-child", "second-child"]
-        siblings = sorted(s.slug for s in self.third_child.get_siblings())
+        expected = ["First Child", "Second Child"]
+        siblings = sorted(s.name for s in self.third_child.get_siblings())
         self.assertEqual(siblings, expected)
 
     def test_is_root(self):
@@ -739,8 +725,8 @@ class DynamicGroupModelTest(DynamicGroupTestBase):  # TODO: BaseModelTestCase mi
         # Assert descendants are deterministic
         d_tree = self.parent.descendants_tree()
         d_flat = self.parent.flatten_descendants_tree(d_tree)
-        expected = {"first-child": 1, "second-child": 1, "third-child": 1, "nested-child": 2}
-        seen = {d.slug: d.depth for d in d_flat}
+        expected = {"First Child": 1, "Second Child": 1, "Third Child": 1, "Nested Child": 2}
+        seen = {d.name: d.depth for d in d_flat}
         self.assertEqual(seen, expected)
 
         # Parent should not be here; nested-child should.
@@ -752,8 +738,8 @@ class DynamicGroupModelTest(DynamicGroupTestBase):  # TODO: BaseModelTestCase mi
         # Assert ancestors are deterministic
         a_tree = self.nested_child.ancestors_tree()
         a_flat = self.nested_child.flatten_ancestors_tree(a_tree)
-        expected = {"third-child": 1, "parent": 2}
-        seen = {a.slug: a.depth for a in a_flat}
+        expected = {"Third Child": 1, "Parent": 2}
+        seen = {a.name: a.depth for a in a_flat}
         self.assertEqual(seen, expected)
 
         # Nested-child should not be here; parent should.
@@ -767,8 +753,8 @@ class DynamicGroupModelTest(DynamicGroupTestBase):  # TODO: BaseModelTestCase mi
         d_tree = group.flatten_descendants_tree(group.descendants_tree())
         m_tree = group.membership_tree()
 
-        d_groups = [d.slug for d in d_tree]
-        m_groups = [m.group.slug for m in m_tree]
+        d_groups = [d.name for d in d_tree]
+        m_groups = [m.group.name for m in m_tree]
 
         d_depths = [d.depth for d in d_tree]
         m_depths = [m.depth for m in m_tree]
@@ -845,8 +831,8 @@ class DynamicGroupModelTest(DynamicGroupTestBase):  # TODO: BaseModelTestCase mi
         prefix = Prefix.objects.first()
 
         relationship = Relationship(
-            name="Device to Prefix",
-            slug="device_to_prefix",
+            label="Device to Prefix",
+            key="device_to_prefix",
             source_type=self.device_ct,
             source_label="My Prefixes",
             source_filter=None,
@@ -865,7 +851,6 @@ class DynamicGroupModelTest(DynamicGroupTestBase):  # TODO: BaseModelTestCase mi
 
         dg = DynamicGroup(
             name="relationships",
-            slug="relationships",
             description="I filter on relationships.",
             filter={"cr_device_to_prefix__destination": [prefix.pk]},
             content_type=self.device_ct,
@@ -898,7 +883,6 @@ class DynamicGroupModelTest(DynamicGroupTestBase):  # TODO: BaseModelTestCase mi
 
         dg = DynamicGroup(
             name="custom_fields",
-            slug="custom_fields",
             description="I filter on custom fields.",
             filter={"cf_favorite_food": "bacon"},
             content_type=self.device_ct,
@@ -923,7 +907,6 @@ class DynamicGroupModelTest(DynamicGroupTestBase):  # TODO: BaseModelTestCase mi
 
         dg = DynamicGroup(
             name="custom_fields",
-            slug="custom_fields",
             description="I filter on the q field",
             filter={"q": "party"},  # Let's party! 🎉
             content_type=self.device_ct,
@@ -1018,10 +1001,6 @@ class DynamicGroupFilterTest(DynamicGroupTestBase):
         params = {"name": ["First Child", "Third Child"]}
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
-    def test_slug(self):
-        params = {"slug": ["invalid-filter"]}
-        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
-
     def test_content_type(self):
         params = {"content_type": ["dcim.device", "virtualization.virtualmachine"]}
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), 7)
@@ -1030,7 +1009,6 @@ class DynamicGroupFilterTest(DynamicGroupTestBase):
         tests = {
             "Devices No Filter": 0,  # name
             "Invalid Filter": 1,  # name
-            "invalid-filter": 1,  # slug
             "A group with a non-matching filter": 1,  # description
             "dcim": 7,  # content_type__app_label
             "device": 7,  # content_type__model
@@ -1060,23 +1038,22 @@ class DynamicGroupMembershipFilterTest(DynamicGroupTestBase):
 
     def test_group(self):
         group_pk = self.queryset.first().group.pk  # expecting 1
-        group_slug = self.queryset.last().group.slug  # expecting 1
+        group_slug = self.queryset.last().group.name  # expecting 1
         params = {"group": [group_pk, group_slug]}
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_parent_group(self):
         parent_group_pk = self.queryset.first().parent_group.pk  # expecting 3
-        parent_group_slug = self.queryset.last().parent_group.slug  # expecting 1
-        params = {"parent_group": [parent_group_pk, parent_group_slug]}
+        parent_group_name = self.queryset.last().parent_group.name  # expecting 1
+        params = {"parent_group": [parent_group_pk, parent_group_name]}
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
 
     def test_search(self):
         tests = {
             "intersection": 2,  # operator
             "First Child": 1,  # group__name
-            "second-child": 1,  # group__slug
             "Parent": 3,  # parent_group__name,
-            "third-child": 2,  # parent_group__slug OR group__slug,
+            "Third Child": 2,  # parent_group__slug OR group__slug,
         }
         for value, cnt in tests.items():
             params = {"q": value}