Add unit tests and integration tests for new add/delete methods

Author: schloerke

integration/tests/posit/connect/test_users.py

@@ -48,21 +48,46 @@ def test_get(self):
         assert self.client.users.get(self.cole["guid"]) == self.cole
 
     # Also tests Groups.members
-    def test_groups(self):
+    def test_user_group_interactions(self):
         try:
-            unit_friends = self.client.groups.create(name="UnitFriends")
-            self.client.post(
-                f"/v1/groups/{unit_friends['guid']}/members",
-                json={"user_guid": self.bill["guid"]},
-            )
+            test_group = self.client.groups.create(name="UnitFriends")
+
+            # `Group.members.count()`
+            assert test_group.members.count() == 0
+
+            # `Group.members.add()`
+            test_group.members.add(self.bill)
+            # `User.groups.add()`
+            assert test_group.members.count() == 1
+            self.cole.groups.add(test_group)
+            assert test_group.members.count() == 2
+
+            # `Group.members.find()`
+            group_users = test_group.members.find()
+            assert len(group_users) == 2
+            assert group_users[0]["guid"] == self.bill["guid"]
+            assert group_users[1]["guid"] == self.cole["guid"]
+
+            # `User.group.find()`
             bill_groups = self.bill.groups.find()
             assert len(bill_groups) == 1
-            assert bill_groups[0]["guid"] == unit_friends["guid"]
+            assert bill_groups[0]["guid"] == test_group["guid"]
+
+            # `Group.members.delete()`
+            test_group.members.delete(self.bill)
+            assert test_group.members.count() == 1
+
+            # `User.groups.delete()`
+            self.cole.groups.delete(test_group)
+            assert test_group.members.count() == 0
+
         finally:
             groups = self.client.groups.find(prefix="UnitFriends")
             if len(groups) > 0:
-                unit_friends = groups[0]
-                unit_friends.delete()
+                test_group = groups[0]
+                test_group.delete()
+
+            assert len(self.client.groups.find(prefix="UnitFriends")) == 0
 
 
 class TestUserContent:

src/posit/connect/groups.py

@@ -116,17 +116,17 @@ def add(self, *args: User, user_guid: Optional[str] = None) -> None:
                 raise ValueError("Only one of `*args` or `user_guid=` should be provided.")
             for i, user in enumerate(args):
                 if not isinstance(user, User):
-                    raise ValueError(f"args[{i}] is not a User object.")
+                    raise TypeError(f"args[{i}] is not a `User` object. Received {user}")
 
             for user in args:
                 self.add(user_guid=user["guid"])
 
             return
 
         if not isinstance(user_guid, str):
-            raise TypeError("`user_guid=` should be a string.")
+            raise TypeError(f"`user_guid=` should be a string. Received {user_guid}")
         if not user_guid:
-            raise ValueError("`user_guid=` should not be empty")
+            raise ValueError("`user_guid=` should not be empty.")
 
         path = f"v1/groups/{self._group_guid}/members"
         url = self._ctx.url + path
@@ -176,17 +176,17 @@ def delete(self, *args: User, user_guid: Optional[str] = None) -> None:
                 raise ValueError("Only one of `*args` or `user_guid=` should be provided.")
             for i, user in enumerate(args):
                 if not isinstance(user, User):
-                    raise TypeError(f"`args[{i}]` is not a `User` object.")
+                    raise TypeError(f"`args[{i}]` is not a `User` object. Received {user}")
 
             for user in args:
                 self.delete(user_guid=user["guid"])
 
             return
 
         if not isinstance(user_guid, str):
-            raise TypeError("`user_guid=` should be a string.")
+            raise TypeError(f"`user_guid=` should be a string. Received {user_guid}")
         if not user_guid:
-            raise ValueError("`user_guid=` should not be empty")
+            raise ValueError("`user_guid=` should not be empty.")
 
         path = f"v1/groups/{self._group_guid}/members/{user_guid}"
         url = self._ctx.url + path

src/posit/connect/users.py

@@ -18,7 +18,7 @@
 
 
 class User(Resource):
-    def __init__(self, ctx: Context, /, **attributes: dict) -> None:
+    def __init__(self, ctx: Context, /, **attributes) -> None:
         super().__init__(ctx.client.resource_params, **attributes)
         self._ctx: Context = ctx
 
@@ -214,7 +214,7 @@ def add(
             for i, group in enumerate(args):
                 if not isinstance(group, Group):
                     raise TypeError(
-                        f"`args[{i}]` is not an instance of Group",
+                        f"`args[{i}]` is not an instance of Group. Received {group}",
                     )
             for group in args:
                 group.members.add(user_guid=self._user_guid)
@@ -282,14 +282,14 @@ def delete(
             for i, group in enumerate(args):
                 if not isinstance(group, Group):
                     raise TypeError(
-                        f"`args[{i}]` is not an instance of Group",
+                        f"`args[{i}]` is not an instance of Group. Received {group}",
                     )
             for group in args:
                 group.members.delete(user_guid=self._user_guid)
             return
 
         if not isinstance(group_guid, str):
-            raise TypeError("`group_guid=` must be a string.")
+            raise TypeError("`group_guid=` must be a string. Received {user}")
         if not group_guid:
             raise ValueError("`group_guid=` must not be empty.")
 

tests/posit/connect/test_groups.py

@@ -1,6 +1,7 @@
 from unittest import mock
 from unittest.mock import Mock
 
+import pytest
 import responses
 
 from posit.connect.client import Client
@@ -43,7 +44,7 @@ def setup_class(cls):
     @responses.activate
     def test_members_count(self):
         responses.get(
-            "https://connect.example/__api__/v1/groups/6f300623-1e0c-48e6-a473-ddf630c0c0c3/members",
+            f"https://connect.example/__api__/v1/groups/{self.group['guid']}/members",
             json=load_mock_dict(f"v1/groups/{self.group['guid']}/members.json"),
         )
         group_members = self.group.members
@@ -53,11 +54,65 @@ def test_members_count(self):
     @responses.activate
     def test_members_find(self):
         responses.get(
-            "https://connect.example/__api__/v1/groups/6f300623-1e0c-48e6-a473-ddf630c0c0c3/members",
+            f"https://connect.example/__api__/v1/groups/{self.group['guid']}/members",
             json=load_mock_dict(f"v1/groups/{self.group['guid']}/members.json"),
         )
 
         group_users = self.group.members.find()
         assert len(group_users) == 2
         for user in group_users:
             assert isinstance(user, User)
+
+    @responses.activate
+    def test_members_add(self):
+        user_guid = "user-guid"
+        responses.post(
+            f"https://connect.example/__api__/v1/groups/{self.group['guid']}/members",
+            json=[],  # No need to return anything
+        )
+
+        user = User(self.client._ctx, guid=user_guid)
+        self.group.members.add(user)
+        self.group.members.add(user, user)
+        self.group.members.add(user_guid=user["guid"])
+
+        with pytest.raises(TypeError):
+            self.group.members.add(
+                "not-a-user",  # pyright: ignore[reportArgumentType]
+            )
+        with pytest.raises(TypeError):
+            self.group.members.add(group_guid=42)  # pyright: ignore[reportCallIssue]
+        with pytest.raises(ValueError):
+            self.group.members.add(user, user_guid=user["guid"])  # pyright: ignore[reportCallIssue]
+        with pytest.raises(ValueError):
+            self.group.members.add(user_guid="")
+
+    @responses.activate
+    def test_members_delete(self):
+        user_guid = "user-guid"
+        responses.get(
+            f"https://connect.example/__api__/v1/groups/{self.group['guid']}",
+            json=dict(self.group),
+        )
+        responses.delete(
+            f"https://connect.example/__api__/v1/groups/{self.group['guid']}/members/{user_guid}",
+            json=[],  # No need to return anything
+        )
+
+        user = User(self.client._ctx, guid=user_guid)
+
+        self.group.members.delete(user)
+        self.group.members.delete(user, user)
+        self.group.members.delete(user_guid=user["guid"])
+
+        with pytest.raises(TypeError):
+            self.group.members.delete(
+                "not-a-user",  # pyright: ignore[reportArgumentType]
+            )
+        with pytest.raises(TypeError):
+            self.group.members.delete(group_guid=42)  # pyright: ignore[reportCallIssue]
+        with pytest.raises(ValueError):
+            self.group.members.delete(user, user_guid=user["guid"])  # pyright: ignore[reportCallIssue]
+
+        with pytest.raises(ValueError):
+            self.group.members.delete(user_guid="")

tests/posit/connect/test_users.py

@@ -6,6 +6,8 @@
 from responses import matchers
 
 from posit.connect.client import Client
+from posit.connect.groups import Group
+from posit.connect.users import User
 
 from .api import load_mock, load_mock_dict
 
@@ -139,13 +141,18 @@ class TestUserGroups:
     def test_groups(self):
         # Get user
         carlos_guid = "20a79ce3-6e87-4522-9faf-be24228800a4"
+        carlos_empty_group_guid = "empty-group-guid"
         responses.get(
             f"https://connect.example/__api__/v1/users/{carlos_guid}",
             json=load_mock_dict(f"v1/users/{carlos_guid}.json"),
         )
+        responses.get(
+            f"https://connect.example/__api__/v1/groups/{carlos_empty_group_guid}/members?page_number=1&page_size=500",
+            json=load_mock_dict(f"v1/groups/{carlos_empty_group_guid}/members.json"),
+        )
         responses.get(
             "https://connect.example/__api__/v1/users",
-            json=load_mock("v1/users?page_number=1&page_size=500.jsonc"),
+            json=load_mock_dict("v1/users?page_number=1&page_size=500.jsonc"),
         )
         # Get groups
         responses.get(
@@ -154,29 +161,90 @@ def test_groups(self):
         )
         # Get group members
         group_guid = "6f300623-1e0c-48e6-a473-ddf630c0c0c3"
-        empty_group_guid = "empty-group-guid"
-        for guid in (group_guid, empty_group_guid):
-            responses.get(
-                f"https://connect.example/__api__/v1/groups/{guid}/members",
-                json=load_mock_dict(f"v1/groups/{guid}/members.json"),
-            )
+        responses.get(
+            f"https://connect.example/__api__/v1/groups/{group_guid}/members",
+            json=load_mock_dict(f"v1/groups/{group_guid}/members.json"),
+        )
 
         client = Client("https://connect.example/", "12345")
-        users = client.users.find()
-        assert len(users) == 2 + 2
 
         carlos = client.users.get(carlos_guid)
         no_groups = carlos.groups.find()
         assert len(no_groups) == 0
 
-        user = users[1]
+        user = client.users.find()[1]
         assert user["guid"] == "87c12c08-11cd-4de1-8da3-12a7579c4998"
 
         groups = user.groups.find()
+        assert isinstance(groups, list)
         assert len(groups) == 1
         group = groups[0]
+        assert isinstance(group, Group)
         assert group["name"] == "Friends"
 
+    @responses.activate
+    def test_groups_add(self):
+        group_guid = "new-group-guid"
+        user_guid = "user-guid"
+        responses.get(
+            f"https://connect.example/__api__/v1/groups/{group_guid}",
+            json={"guid": group_guid},
+        )
+        responses.post(
+            f"https://connect.example/__api__/v1/groups/{group_guid}/members",
+            json=[],
+        )
+
+        client = Client("https://connect.example/", "12345")
+
+        user = User(client._ctx, guid=user_guid)
+        new_group = Group(client._ctx, guid=group_guid)
+        # Add via Group
+        user.groups.add(new_group)
+        # Add via guid
+        user.groups.add(group_guid=new_group["guid"])
+
+        with pytest.raises(TypeError):
+            user.groups.add(
+                "not a group",  # pyright: ignore[reportArgumentType]
+            )
+        with pytest.raises(ValueError):
+            user.groups.add(group_guid="")
+        with pytest.raises(ValueError):
+            user.groups.add(new_group, group_guid=new_group["guid"])  # pyright: ignore[reportCallIssue]
+
+    @responses.activate
+    def test_groups_delete(self):
+        group_guid = "new-group-guid"
+        user_guid = "user-guid"
+        responses.get(
+            f"https://connect.example/__api__/v1/groups/{group_guid}",
+            json={"guid": group_guid},
+        )
+        responses.delete(
+            f"https://connect.example/__api__/v1/groups/{group_guid}/members/{user_guid}",
+            json=[],
+        )
+
+        client = Client("https://connect.example/", "12345")
+
+        user = User(client._ctx, guid=user_guid)
+        group = Group(client._ctx, guid=group_guid)
+
+        # Delete via Group
+        user.groups.delete(group)
+        # Delete via guid
+        user.groups.delete(group_guid=group["guid"])
+
+        with pytest.raises(TypeError):
+            user.groups.delete(
+                "not a group",  # pyright: ignore[reportArgumentType]
+            )
+        with pytest.raises(ValueError):
+            user.groups.delete(group_guid="")
+        with pytest.raises(ValueError):
+            user.groups.delete(group, group_guid=group["guid"])  # pyright: ignore[reportCallIssue]
+
 
 class TestUsers:
     @responses.activate