more tests & polishing (#9)

* polished users,groups,apps

Signed-off-by: Alexander Piskun <[email protected]>

nc_py_api/apps.py

@@ -23,26 +23,24 @@ def enable(self, app_name: str) -> None:
             raise ValueError("`app_name` parameter can not be empty")
         self._session.ocs(method="POST", path=f"{ENDPOINT}/{app_name}")
 
-    def list(self, enabled: Optional[bool] = None) -> list[str]:
+    def get_list(self, enabled: Optional[bool] = None) -> list[str]:
         params = None
         if enabled is not None:
             params = {"filter": "enabled" if enabled else "disabled"}
         result = self._session.ocs(method="GET", path=ENDPOINT, params=params)
-        if not isinstance(result, dict):
-            raise ValueError("invalid type of data returned")
         return list(result["apps"].values()) if isinstance(result["apps"], dict) else result["apps"]
 
     def is_installed(self, app_name: str) -> bool:
         if not app_name:
             raise ValueError("`app_name` parameter can not be empty")
-        return app_name in self.list()
+        return app_name in self.get_list()
 
     def is_enabled(self, app_name: str) -> bool:
         if not app_name:
             raise ValueError("`app_name` parameter can not be empty")
-        return app_name in self.list(enabled=True)
+        return app_name in self.get_list(enabled=True)
 
     def is_disabled(self, app_name: str) -> bool:
         if not app_name:
             raise ValueError("`app_name` parameter can not be empty")
-        return app_name in self.list(enabled=False)
+        return app_name in self.get_list(enabled=False)

nc_py_api/users.py

@@ -15,55 +15,58 @@ class UserAPI:
     def __init__(self, session: NcSessionBasic):
         self._session = session
 
-    def list(self, mask: Optional[str] = "", limit: Optional[int] = None, offset: Optional[int] = None) -> dict:
+    def get_list(
+        self, mask: Optional[str] = "", limit: Optional[int] = None, offset: Optional[int] = None
+    ) -> list[str]:
         data = kwargs_to_dict(["search", "limit", "offset"], search=mask, limit=limit, offset=offset)
         response_data = self._session.ocs(method="GET", path=ENDPOINT, params=data)
         return response_data["users"] if response_data else {}
 
-    def get(self, user_id: str = "") -> dict:
+    def get_details(self, user_id: str = "") -> dict:
         if not user_id:
             user_id = self._session.user
         if not user_id:
             raise ValueError("user_id can not be empty.")
         return self._session.ocs(method="GET", path=f"{ENDPOINT}/{user_id}")
 
-    def create(self, user_id: str, **kwargs) -> dict:
+    def create(self, user_id: str, **kwargs) -> None:
         password = kwargs.get("password", None)
         email = kwargs.get("email", None)
-        if password is None and email is None:
+        if not password and not email:
             raise ValueError("Either password or email must be set")
         data = {"userid": user_id}
         for k in ("password", "displayname", "email", "groups", "subadmin", "quota", "language"):
             if k in kwargs:
                 data[k] = kwargs[k]
-        return self._session.ocs(method="POST", path=ENDPOINT, params=data)
+        self._session.ocs(method="POST", path=ENDPOINT, params=data)
 
-    def delete(self, user_id: str) -> dict:
-        return self._session.ocs(method="DELETE", path=f"{ENDPOINT}/{user_id}")
+    def delete(self, user_id: str) -> None:
+        self._session.ocs(method="DELETE", path=f"{ENDPOINT}/{user_id}")
 
-    def enable(self, user_id: str) -> dict:
-        return self._session.ocs(method="PUT", path=f"{ENDPOINT}/{user_id}/enable")
+    def enable(self, user_id: str) -> None:
+        self._session.ocs(method="PUT", path=f"{ENDPOINT}/{user_id}/enable")
 
-    def disable(self, user_id: str) -> dict:
-        return self._session.ocs(method="PUT", path=f"{ENDPOINT}/{user_id}/disable")
+    def disable(self, user_id: str) -> None:
+        self._session.ocs(method="PUT", path=f"{ENDPOINT}/{user_id}/disable")
 
-    def resend_welcome_email(self) -> dict:
-        return self._session.ocs(method="POST", path=f"{ENDPOINT}/user/welcome")
+    def resend_welcome_email(self) -> None:
+        self._session.ocs(method="POST", path=f"{ENDPOINT}/admin/welcome")
 
-    def editable_fields(self) -> dict:
+    def editable_fields(self) -> list[str]:
         return self._session.ocs(method="GET", path=f"{ENDPOINT_BASE}/user/fields")
 
-    def edit(self, user_id: str, **kwargs) -> dict:
-        return self._session.ocs(method="PUT", path=f"{ENDPOINT}/{user_id}", params={**kwargs})
+    def edit(self, user_id: str, **kwargs) -> None:
+        for k, v in kwargs.items():
+            self._session.ocs(method="PUT", path=f"{ENDPOINT}/{user_id}", params={"key": k, "value": v})
 
-    def add_to_group(self, user_id: str, group_id: str) -> dict:
-        return self._session.ocs(method="POST", path=f"{ENDPOINT}/{user_id}/groups", params={"groupid": group_id})
+    def add_to_group(self, user_id: str, group_id: str) -> None:
+        self._session.ocs(method="POST", path=f"{ENDPOINT}/{user_id}/groups", params={"groupid": group_id})
 
-    def remove_from_group(self, user_id: str, group_id: str) -> dict:
-        return self._session.ocs(method="DELETE", path=f"{ENDPOINT}/{user_id}/groups", params={"groupid": group_id})
+    def remove_from_group(self, user_id: str, group_id: str) -> None:
+        self._session.ocs(method="DELETE", path=f"{ENDPOINT}/{user_id}/groups", params={"groupid": group_id})
 
-    def promote_to_subadmin(self, user_id: str, group_id: str) -> dict:
-        return self._session.ocs(method="POST", path=f"{ENDPOINT}/{user_id}/subadmins", params={"groupid": group_id})
+    def promote_to_subadmin(self, user_id: str, group_id: str) -> None:
+        self._session.ocs(method="POST", path=f"{ENDPOINT}/{user_id}/subadmins", params={"groupid": group_id})
 
-    def demote_from_subadmin(self, user_id: str, group_id: str) -> dict:
-        return self._session.ocs(method="DELETE", path=f"{ENDPOINT}/{user_id}/subadmins", params={"groupid": group_id})
+    def demote_from_subadmin(self, user_id: str, group_id: str) -> None:
+        self._session.ocs(method="DELETE", path=f"{ENDPOINT}/{user_id}/subadmins", params={"groupid": group_id})

nc_py_api/users_groups.py

@@ -23,7 +23,9 @@ class UsersGroupsAPI:
     def __init__(self, session: NcSessionBasic):
         self._session = session
 
-    def get(self, mask: Optional[str] = None, limit: Optional[int] = None, offset: Optional[int] = None) -> list[str]:
+    def get_list(
+        self, mask: Optional[str] = None, limit: Optional[int] = None, offset: Optional[int] = None
+    ) -> list[str]:
         data = kwargs_to_dict(["search", "limit", "offset"], search=mask, limit=limit, offset=offset)
         response_data = self._session.ocs(method="GET", path=ENDPOINT, params=data)
         return response_data["groups"] if response_data else []

nc_py_api/users_statuses.py

@@ -40,7 +40,7 @@ def __init__(self, session: NcSessionBasic):
     def available(self) -> bool:
         return not check_capabilities("user_status", self._session.capabilities)
 
-    def get_all(self, limit: Optional[int] = None, offset: Optional[int] = None) -> list[UserStatus]:
+    def get_list(self, limit: Optional[int] = None, offset: Optional[int] = None) -> list[UserStatus]:
         require_capabilities("user_status", self._session.capabilities)
         data = kwargs_to_dict(["limit", "offset"], limit=limit, offset=offset)
         return self._session.ocs(method="GET", path=f"{ENDPOINT}/statuses", params=data)

tests/apps_test.py

@@ -9,14 +9,14 @@
 
 @pytest.mark.parametrize("nc", NC_TO_TEST)
 def test_list_apps_types(nc):
-    assert isinstance(nc.apps.list(), list)
-    assert isinstance(nc.apps.list(enabled=True), list)
-    assert isinstance(nc.apps.list(enabled=False), list)
+    assert isinstance(nc.apps.get_list(), list)
+    assert isinstance(nc.apps.get_list(enabled=True), list)
+    assert isinstance(nc.apps.get_list(enabled=False), list)
 
 
 @pytest.mark.parametrize("nc", NC_TO_TEST)
 def test_list_apps(nc):
-    apps = nc.apps.list()
+    apps = nc.apps.get_list()
     assert apps
     assert APP_NAME in apps
 
@@ -33,3 +33,17 @@ def test_enable_disable_app(nc):
     nc.apps.enable(APP_NAME)
     assert nc.apps.is_enabled(APP_NAME)
     assert nc.apps.is_installed(APP_NAME)
+
+
+@pytest.mark.parametrize("nc", NC_TO_TEST[:1])
+def test_invalid_param(nc):
+    with pytest.raises(ValueError):
+        nc.apps.is_enabled("")
+    with pytest.raises(ValueError):
+        nc.apps.is_installed("")
+    with pytest.raises(ValueError):
+        nc.apps.is_disabled("")
+    with pytest.raises(ValueError):
+        nc.apps.enable("")
+    with pytest.raises(ValueError):
+        nc.apps.disable("")

tests/groups_test.py

@@ -27,37 +27,37 @@ def test_create_delete_group(nc, params):
 
 @pytest.mark.skipif(not isinstance(NC_TO_TEST[:1][0], Nextcloud), reason="Not available for NextcloudApp.")
 @pytest.mark.parametrize("nc", NC_TO_TEST[:1])
-def test_get_group(nc):
+def test_group_get_list(nc):
     for i in (TEST_GROUP_NAME, TEST_GROUP_NAME2):
         try:
             nc.users_groups.create(i)
         except NextcloudException:
             pass
-    groups = nc.users_groups.get()
+    groups = nc.users_groups.get_list()
     assert isinstance(groups, list)
     assert len(groups) >= 2
     assert TEST_GROUP_NAME in groups
     assert TEST_GROUP_NAME2 in groups
-    groups = nc.users_groups.get(mask=TEST_GROUP_NAME)
+    groups = nc.users_groups.get_list(mask=TEST_GROUP_NAME)
     assert len(groups) == 1
-    groups = nc.users_groups.get(limit=1)
+    groups = nc.users_groups.get_list(limit=1)
     assert len(groups) == 1
-    assert groups[0] != nc.users_groups.get(limit=1, offset=1)[0]
+    assert groups[0] != nc.users_groups.get_list(limit=1, offset=1)[0]
     nc.users_groups.delete(TEST_GROUP_NAME)
     nc.users_groups.delete(TEST_GROUP_NAME2)
 
 
 @pytest.mark.skipif(not isinstance(NC_TO_TEST[:1][0], Nextcloud), reason="Not available for NextcloudApp.")
 @pytest.mark.parametrize("nc", NC_TO_TEST[:1])
 def test_get_non_existing_group(nc):
-    groups = nc.users_groups.get(mask="Such group should not be present")
+    groups = nc.users_groups.get_list(mask="Such group should not be present")
     assert isinstance(groups, list)
     assert not groups
 
 
 @pytest.mark.skipif(not isinstance(NC_TO_TEST[:1][0], Nextcloud), reason="Not available for NextcloudApp.")
 @pytest.mark.parametrize("nc", NC_TO_TEST[:1])
-def test_get_group_details(nc):
+def test_group_get_details(nc):
     try:
         nc.users_groups.delete(TEST_GROUP_NAME)
     except NextcloudException:

tests/misc_test.py

@@ -10,3 +10,12 @@ def test_check_error(code):
             check_error(code)
     else:
         check_error(code)
+
+
+def test_nc_exception_to_str():
+    reason = "this is a reason"
+    info = "some info"
+    try:
+        raise NextcloudException(status_code=666, reason=reason, info=info)
+    except NextcloudException as e:
+        assert str(e) == f"[666] {reason} <{info}>"

tests/users_statuses_test.py

@@ -52,8 +52,8 @@ def test_get_predefined(nc):
 
 
 @pytest.mark.parametrize("nc", NC_TO_TEST)
-def test_get_all(nc):
-    r_all = nc.users_statuses.get_all()
+def test_get_list(nc):
+    r_all = nc.users_statuses.get_list()
     assert r_all
     assert isinstance(r_all, list)
     r_current = nc.users_statuses.get_current()

tests/users_test.py

@@ -10,15 +10,31 @@
 
 
 @pytest.mark.parametrize("nc", NC_TO_TEST)
-def test_get_user(nc):
-    admin = nc.users.get("admin")
+def test_get_user_details(nc):
+    admin = nc.users.get_details("admin")
     assert admin
+    current_user = nc.users.get_details()
+    assert current_user
+    admin.pop("quota", None)  # `quota` is a little bit different
+    current_user.pop("quota", None)
+    assert admin == current_user
+
+
+@pytest.mark.parametrize("nc", NC_TO_TEST)
+def test_get_current_user_wo_user(nc):
+    orig_user = nc._session.user
+    try:
+        nc._session.user = ""
+        with pytest.raises(ValueError):
+            nc.users.get_details()
+    finally:
+        nc._session.user = orig_user
 
 
 @pytest.mark.parametrize("nc", NC_TO_TEST)
 def test_get_user_404(nc):
     with pytest.raises(NextcloudException):
-        nc.users.get("non existing user")
+        nc.users.get_details("non existing user")
 
 
 @pytest.mark.skipif(not isinstance(NC_TO_TEST[:1][0], Nextcloud), reason="Not available for NextcloudApp.")
@@ -33,6 +49,21 @@ def test_create_user(nc):
         nc.users.create(TEST_USER_NAME, password=TEST_USER_PASSWORD)
 
 
+@pytest.mark.skipif(not isinstance(NC_TO_TEST[:1][0], Nextcloud), reason="Not available for NextcloudApp.")
+@pytest.mark.parametrize("nc", NC_TO_TEST[:1])
+def test_create_user_no_name_mail(nc):
+    try:
+        nc.users.delete(TEST_USER_NAME)
+    except NextcloudException:
+        pass
+    with pytest.raises(ValueError):
+        nc.users.create(TEST_USER_NAME)
+    with pytest.raises(ValueError):
+        nc.users.create(TEST_USER_NAME, password="")
+    with pytest.raises(ValueError):
+        nc.users.create(TEST_USER_NAME, email="")
+
+
 @pytest.mark.skipif(not isinstance(NC_TO_TEST[:1][0], Nextcloud), reason="Not available for NextcloudApp.")
 @pytest.mark.parametrize("nc", NC_TO_TEST[:1])
 def test_delete_user(nc):
@@ -47,17 +78,18 @@ def test_delete_user(nc):
 
 @pytest.mark.skipif(not isinstance(NC_TO_TEST[:1][0], Nextcloud), reason="Not available for NextcloudApp.")
 @pytest.mark.parametrize("nc", NC_TO_TEST[:1])
-def test_list_users(nc):
+def test_users_get_list(nc):
     try:
         nc.users.create(TEST_USER_NAME, password=TEST_USER_PASSWORD)
     except NextcloudException:
         pass
-    users = nc.users.list()
+    users = nc.users.get_list()
+    assert isinstance(users, list)
     assert "admin" in users
-    users = nc.users.list(limit=1)
+    users = nc.users.get_list(limit=1)
     assert len(users) == 1
-    assert users[0] != nc.users.list(limit=1, offset=1)[0]
-    users = nc.users.list(mask="test_cover_")
+    assert users[0] != nc.users.get_list(limit=1, offset=1)[0]
+    users = nc.users.get_list(mask="test_cover_")
     assert len(users) == 1
     nc.users.delete(TEST_USER_NAME)
 
@@ -70,9 +102,35 @@ def test_enable_disable_user(nc):
     except NextcloudException:
         pass
     nc.users.disable(TEST_USER_NAME)
-    user = nc.users.get(TEST_USER_NAME)
+    user = nc.users.get_details(TEST_USER_NAME)
     assert not user["enabled"]
     nc.users.enable(TEST_USER_NAME)
-    user = nc.users.get(TEST_USER_NAME)
+    user = nc.users.get_details(TEST_USER_NAME)
     assert user["enabled"]
     nc.users.delete(TEST_USER_NAME)
+
+
+@pytest.mark.skipif(not isinstance(NC_TO_TEST[:1][0], Nextcloud), reason="Not available for NextcloudApp.")
+@pytest.mark.parametrize("nc", NC_TO_TEST[:1])
+def test_user_editable_fields(nc):
+    editable_fields = nc.users.editable_fields()
+    assert isinstance(editable_fields, list)
+    assert editable_fields
+
+
+@pytest.mark.skipif(not isinstance(NC_TO_TEST[:1][0], Nextcloud), reason="Not available for NextcloudApp.")
+@pytest.mark.parametrize("nc", NC_TO_TEST[:1])
+def test_edit_user(nc):
+    nc.users.edit(nc.user, address="Le Pame")
+    current_user = nc.users.get_details()
+    assert current_user["address"] == "Le Pame"
+    nc.users.edit(nc.user, address="", email="[email protected]")
+    current_user = nc.users.get_details()
+    assert current_user["address"] == ""
+    assert current_user["email"] == "[email protected]"
+
+
+@pytest.mark.skipif(not isinstance(NC_TO_TEST[:1][0], Nextcloud), reason="Not available for NextcloudApp.")
+@pytest.mark.parametrize("nc", NC_TO_TEST[:1])
+def test_resend_user_email(nc):
+    nc.users.resend_welcome_email()