feat: Add/test many tag, tags, and content item tags methods

integration/tests/posit/connect/test_tags.py

@@ -0,0 +1,174 @@
+from typing import TYPE_CHECKING
+
+from posit import connect
+
+if TYPE_CHECKING:
+    from posit.connect.content import ContentItem
+
+
+# add integration tests here!
+class TestTags:
+    @classmethod
+    def setup_class(cls):
+        cls.client = connect.Client()
+        cls.contentA = cls.client.content.create(name="Content_A")
+        cls.contentB = cls.client.content.create(name="Content_B")
+        cls.contentC = cls.client.content.create(name="Content_C")
+
+    @classmethod
+    def teardown_class(cls):
+        assert len(cls.client.tags.find()) == 0
+        cls.contentA.delete()
+        cls.contentB.delete()
+        cls.contentC.delete()
+        assert len(cls.client.content.find()) == 0
+
+    def test_tags_find(self):
+        tags = self.client.tags.find()
+        assert len(tags) == 0
+
+    def test_tags_create_destroy(self):
+        tagA = self.client.tags.create(name="tagA")
+        tagB = self.client.tags.create(name="tagB")
+        tagC = self.client.tags.create(name="tagC", parent=tagA)
+
+        assert len(self.client.tags.find()) == 3
+
+        tagA.destroy()
+        tagB.destroy()
+        ## Deleted when tag A is deleted
+        # tagC.destroy()
+
+        assert len(self.client.tags.find()) == 0
+
+    def test_tag_descendants(self):
+        tagA = self.client.tags.create(name="tagA")
+        tagB = self.client.tags.create(name="tagB")
+        tagC = self.client.tags.create(name="tagC", parent=tagA)
+        tagD = self.client.tags.create(name="tagD", parent=tagC)
+
+        assert tagA.descendant_tags.find() == [tagC, tagD]
+
+        assert len(tagB.descendant_tags.find()) == 0
+        assert tagC.descendant_tags.find() == [tagD]
+
+        # cleanup
+        tagA.destroy()
+        tagB.destroy()
+        assert len(self.client.tags.find()) == 0
+
+    def test_tag_children(self):
+        tagA = self.client.tags.create(name="tagA_children")
+        tagB = self.client.tags.create(name="tagB_children")
+        tagC = self.client.tags.create(name="tagC_children", parent=tagA)
+        tagD = self.client.tags.create(name="tagD_children", parent=tagC)
+
+        assert tagA.children_tags.find() == [tagC]
+        assert tagB.children_tags.find() == []
+        assert tagC.children_tags.find() == [tagD]
+
+        # cleanup
+        tagA.destroy()
+        tagB.destroy()
+        assert len(self.client.tags.find()) == 0
+
+    def test_tag_parent(self):
+        tagA = self.client.tags.create(name="tagA_parent")
+        tagB = self.client.tags.create(name="tagB_parent")
+        tagC = self.client.tags.create(name="tagC_parent", parent=tagA)
+        tagD = self.client.tags.create(name="tagD_parent", parent=tagC)
+
+        assert tagA.parent_tag is None
+        assert tagB.parent_tag is None
+        assert tagC.parent_tag == tagA
+        assert tagD.parent_tag == tagC
+
+        # cleanup
+        tagA.destroy()
+        tagB.destroy()
+        assert len(self.client.tags.find()) == 0
+
+    def test_content_item_tags(self):
+        tagRoot = self.client.tags.create(name="tagRoot_content_item_tags")
+        tagA = self.client.tags.create(name="tagA_content_item_tags", parent=tagRoot)
+        tagB = self.client.tags.create(name="tagB_content_item_tags", parent=tagRoot)
+        tagC = self.client.tags.create(name="tagC_content_item_tags", parent=tagA)
+        tagD = self.client.tags.create(name="tagD_content_item_tags", parent=tagC)
+
+        assert len(self.contentA.tags.find()) == 0
+
+        self.contentA.tags.add(tagD)
+        self.contentA.tags.add(tagB)
+
+        # tagB, tagD, tagC (parent of tagD), tagA (parent of tagC)
+        # tagD + tagC
+        # tagRoot is considered a "category" and is "not a tag"
+        assert len(self.contentA.tags.find()) == 4
+
+        # Removes tagB
+        self.contentA.tags.delete(tagB)
+        assert len(self.contentA.tags.find()) == 4 - 1
+
+        # Removes tagC and tagD (parent of tagC)
+        self.contentA.tags.delete(tagC)
+        assert len(self.contentA.tags.find()) == 4 - 1 - 2
+
+        # cleanup
+        tagRoot.destroy()
+        assert len(self.client.tags.find()) == 0
+
+    def test_tag_content_items(self):
+        tagRoot = self.client.tags.create(name="tagRoot_tag_content_items")
+        tagA = self.client.tags.create(name="tagA_tag_content_items", parent=tagRoot)
+        tagB = self.client.tags.create(name="tagB_tag_content_items", parent=tagRoot)
+        tagC = self.client.tags.create(name="tagC_tag_content_items", parent=tagA)
+        tagD = self.client.tags.create(name="tagD_tag_content_items", parent=tagC)
+
+        assert len(tagA.content_items.find()) == 0
+        assert len(tagB.content_items.find()) == 0
+        assert len(tagC.content_items.find()) == 0
+        assert len(tagD.content_items.find()) == 0
+
+        self.contentA.tags.add(tagD)
+        self.contentA.tags.add(tagB)
+
+        self.contentB.tags.add(tagA)
+        self.contentB.tags.add(tagC)
+
+        self.contentC.tags.add(tagC)
+
+        assert len(self.contentA.tags.find()) == 4
+        assert len(self.contentB.tags.find()) == 2
+        assert len(self.contentC.tags.find()) == 2
+
+        assert len(tagA.content_items.find()) == 3
+        assert len(tagB.content_items.find()) == 1
+        assert len(tagC.content_items.find()) == 3
+
+        # Make sure unique content items are found
+        content_items_list: list[ContentItem] = []
+        for tag in [tagA, *tagA.descendant_tags.find()]:
+            content_items_list.extend(tag.content_items.find())
+        # Get unique content_item guids
+        content_item_guids = set[str]()
+        for content_item in content_items_list:
+            if content_item["guid"] not in content_item_guids:
+                content_item_guids.add(content_item["guid"])
+
+        assert content_item_guids == {
+            self.contentA["guid"],
+            self.contentB["guid"],
+            self.contentC["guid"],
+        }
+
+        self.contentA.tags.delete(tagRoot)
+        self.contentB.tags.delete(tagRoot)
+        self.contentC.tags.delete(tagRoot)
+
+        assert len(tagA.content_items.find()) == 0
+        assert len(tagB.content_items.find()) == 0
+        assert len(tagC.content_items.find()) == 0
+
+        # cleanup
+        tagRoot.destroy()
+        assert len(self.client.tags.find()) == 0

src/posit/connect/client.py

@@ -6,6 +6,8 @@
 
 from requests import Response, Session
 
+from posit.connect.tags import Tags
+
 from . import hooks, me
 from .auth import Auth
 from .config import Config
@@ -229,6 +231,28 @@ def content(self) -> Content:
         """
         return Content(self.resource_params)
 
+    @property
+    def tags(self) -> Tags:
+        """
+        The tags resource interface.
+
+        Returns
+        -------
+        Tags
+            The tags resource instance.
+
+        Examples
+        --------
+        ```python
+        import posit
+
+        client = posit.connect.Client()
+
+        tags = client.tags.find()
+        ```
+        """
+        return Tags(self._ctx, "v1/tags")
+
     @property
     def metrics(self) -> Metrics:
         """

src/posit/connect/content.py

@@ -28,6 +28,7 @@
 from .packages import ContentPackagesMixin as PackagesMixin
 from .permissions import Permissions
 from .resources import Resource, ResourceParameters, Resources
+from .tags import ContentItemTags
 from .vanities import VanityMixin
 from .variants import Variants
 
@@ -496,6 +497,16 @@ def is_rendered(self) -> bool:
             "quarto-static",
         }
 
+    @property
+    def tags(self) -> ContentItemTags:
+        path = f"v1/content/{self['guid']}/tags"
+        return ContentItemTags(
+            self._ctx,
+            path,
+            tags_path="v1/tags",
+            content_guid=self["guid"],
+        )
+
 
 class Content(Resources):
     """Content resource.

src/posit/connect/permissions.py

@@ -158,7 +158,7 @@ def destroy(self, *permissions: str | Group | User | Permission) -> list[Permiss
         Returns
         -------
         list[Permission]
-            The removed permissions. If a permission is not found, there is nothing to remove and 
+            The removed permissions. If a permission is not found, there is nothing to remove and
             it is not included in the returned list.
 
         Examples