rocketchat-API 3.2.0__tar.gz → 3.4.0__tar.gz

{rocketchat_api-3.2.0 → rocketchat_api-3.4.0}/.github/workflows/release.yml

@@ -28,3 +28,11 @@ jobs:
           python3 -m build
       - name: Publish package distributions to PyPI
         uses: pypa/gh-action-pypi-publish@release/v1
+      - name: Announce release
+        uses: jadolg/rocketchat-notification-action@v2.0.0
+        with:
+          server: https://open.rocket.chat
+          message: A new version (${{ github.event.release.tag_name }}) has been released! ${{ github.event.release.html_url }}
+          user: ${{ secrets.ROCKETCHAT_USER }}
+          password: ${{ secrets.ROCKETCHAT_PASSWORD }}
+          channel: "#python_rocketchat_api"

{rocketchat_api-3.2.0 → rocketchat_api-3.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rocketchat_API
-Version: 3.2.0
+Version: 3.4.0
 Summary: Python API wrapper for Rocket.Chat
 Author-email: "Jorge Alberto Díaz Orozco (Akiel)" <diazorozcoj@gmail.com>
 Maintainer-email: "Jorge Alberto Díaz Orozco (Akiel)" <diazorozcoj@gmail.com>
@@ -16,6 +16,7 @@ Provides-Extra: test
 Requires-Dist: black; extra == "test"
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pymongo; extra == "test"
 Requires-Dist: requests; extra == "test"
 Requires-Dist: semver; extra == "test"
 Dynamic: license-file

{rocketchat_api-3.2.0 → rocketchat_api-3.4.0}/pyproject.toml

@@ -49,6 +49,7 @@ test = [
     "black",
     "pytest",
     "pytest-cov",
+    "pymongo",
     "requests",
     "semver",
 ]

rocketchat_api-3.4.0/rocketchat_API/APISections/banners.py

@@ -0,0 +1,23 @@
+from rocketchat_API.APISections.base import RocketChatBase
+
+
+class RocketChatBanners(RocketChatBase):
+    def banners(self, platform, **kwargs):
+        """Gets the banner to be shown to the authenticated user"""
+        return self.call_api_get(
+            "banners",
+            platform=platform,
+            kwargs=kwargs,
+        )
+
+    def banners_get_by_id(self, banner_id, platform, **kwargs):
+        """Gets a banner by its ID."""
+        return self.call_api_get(
+            "banners/{}".format(banner_id),
+            platform=platform,
+            kwargs=kwargs,
+        )
+
+    def banners_dismiss(self, banner_id, **kwargs):
+        """Dismisses a banner for the authenticated user."""
+        return self.call_api_post("banners.dismiss", bannerId=banner_id, kwargs=kwargs)

{rocketchat_api-3.2.0 → rocketchat_api-3.4.0}/rocketchat_API/APISections/base.py

@@ -200,24 +200,37 @@ class RocketChatBase:
             )
         )
 
-    def call_api_post(self, method, files=None, use_json=None, **kwargs):
-        reduced_args = self.__reduce_kwargs(kwargs)
-        # Since pass is a reserved word in Python it has to be injected on the request dict
-        # Some methods use pass (users.register) and others password (users.create)
-        if "password" in reduced_args and method != "users.create":
-            reduced_args["pass"] = reduced_args["password"]
-            del reduced_args["password"]
-        if use_json is None:
-            # see https://requests.readthedocs.io/en/master/user/quickstart/#more-complicated-post-requests
-            # > The json parameter is ignored if either data or files is passed.
-            # If files are sent, json should not be used
-            use_json = files is None
-        if use_json:
+    def call_api_post(self, method, body=None, files=None, use_json=None, **kwargs):
+        """Send a POST request to the API.
+
+        There are two modes of operation:
+
+        1. **Raw body** — pass ``body`` directly. The value is serialized as-is
+           via ``json=body``, which supports any JSON-serializable structure
+           (lists, dicts, etc.). ``kwargs`` are ignored in this mode.
+
+        2. **Keyword arguments** (default) — individual kwargs are collected
+           into a dict and sent as the request payload.  By default the payload
+           is sent as JSON (``json=``), but when ``files`` are provided it
+           falls back to form-encoded ``data=`` because requests ignores the
+           ``json`` parameter when ``files`` is set.  You can override this
+           with ``use_json=True/False``.
+
+        :param method:   API method path, appended to ``self.api_path``.
+        :param body:     A raw JSON-serializable payload (e.g. a list).
+                         When provided, ``kwargs``, ``files``, and ``use_json``
+                         are ignored.
+        :param files:    Files to upload (passed to ``requests``).
+        :param use_json: Force JSON (True) or form-encoded (False) encoding.
+                         Defaults to JSON when no files are attached.
+        """
+        url = self.server_url + self.api_path + method
+
+        if body is not None:
             return json_or_error(
                 self.session.post(
-                    self.server_url + self.api_path + method,
-                    json=reduced_args,
-                    files=files,
+                    url,
+                    json=body,
                     headers=self.headers,
                     verify=self.ssl_verify,
                     cert=self.cert,
@@ -226,10 +239,21 @@ class RocketChatBase:
                 )
             )
 
+        reduced_args = self.__reduce_kwargs(kwargs)
+
+        # "pass" is a Python reserved word, but some endpoints (e.g.
+        # users.register) expect it instead of "password".
+        if "password" in reduced_args and method != "users.create":
+            reduced_args["pass"] = reduced_args.pop("password")
+
+        if use_json is None:
+            use_json = files is None
+
         return json_or_error(
             self.session.post(
-                self.server_url + self.api_path + method,
-                data=reduced_args,
+                url,
+                json=reduced_args if use_json else None,
+                data=None if use_json else reduced_args,
                 files=files,
                 headers=self.headers,
                 verify=self.ssl_verify,

{rocketchat_api-3.2.0 → rocketchat_api-3.4.0}/rocketchat_API/APISections/chat.py

@@ -116,3 +116,64 @@ class RocketChatChat(RocketChatBase):
             roomId=room_id,
             kwargs=kwargs,
         )
+
+    def chat_unfollow_message(self, mid, **kwargs):
+        """Unfollow a message."""
+        return self.call_api_post("chat.unfollowMessage", mid=mid, kwargs=kwargs)
+
+    @paginated("messages")
+    def chat_get_deleted_messages(self, room_id, since, **kwargs):
+        """Get deleted messages from a specific date."""
+        return self.call_api_get(
+            "chat.getDeletedMessages", roomId=room_id, since=since, kwargs=kwargs
+        )
+
+    @paginated("messages")
+    def chat_get_pinned_messages(self, room_id, **kwargs):
+        """Get pinned messages of a room."""
+        return self.call_api_get(
+            "chat.getPinnedMessages", roomId=room_id, kwargs=kwargs
+        )
+
+    def chat_ignore_user(self, rid, user_id, ignore=True, **kwargs):
+        """Ignore or unignore a user in chat."""
+        return self.call_api_get(
+            "chat.ignoreUser", rid=rid, userId=user_id, ignore=ignore, kwargs=kwargs
+        )
+
+    def chat_sync_thread_list(self, rid, updated_since, **kwargs):
+        """List threads in a room updated since a given ISO date."""
+        return self.call_api_get(
+            "chat.syncThreadsList", rid=rid, updatedSince=updated_since, kwargs=kwargs
+        )
+
+    def chat_sync_thread_messages(self, tmid, updated_since, **kwargs):
+        """List the messages in a thread along with any data updates from a specified date."""
+        return self.call_api_get(
+            "chat.syncThreadMessages",
+            tmid=tmid,
+            updatedSince=updated_since,
+            kwargs=kwargs,
+        )
+
+    def chat_sync_messages(self, room_id, last_update, **kwargs):
+        """List the messages in a room along with any data updates from a specified date."""
+        return self.call_api_get(
+            "chat.syncMessages", roomId=room_id, lastUpdate=last_update, kwargs=kwargs
+        )
+
+    @paginated("threads")
+    def chat_get_threads_list(self, rid, **kwargs):
+        """Get a list of the thread conversations in a room."""
+        return self.call_api_get("chat.getThreadsList", rid=rid, kwargs=kwargs)
+
+    def chat_get_url_preview(self, room_id, url, **kwargs):
+        """Use this endpoint to get a URL preview that can be used in the send and update message endpoints."""
+        return self.call_api_get(
+            "chat.getURLPreview", roomId=room_id, url=url, kwargs=kwargs
+        )
+
+    @paginated("messages")
+    def chat_get_discussions(self, room_id, **kwargs):
+        """Get the discussions in a room."""
+        return self.call_api_get("chat.getDiscussions", roomId=room_id, kwargs=kwargs)

{rocketchat_api-3.2.0 → rocketchat_api-3.4.0}/rocketchat_API/APISections/dm.py

@@ -83,3 +83,7 @@ class RocketChatDM(RocketChatBase):
         if user_name:
             return self.call_api_get("dm.counters", roomId=room_id, username=user_name)
         return self.call_api_get("dm.counters", roomId=room_id)
+
+    def dm_delete(self, room_id, **kwargs):
+        """Delete a direct message room. Requires view-room-administration permission."""
+        return self.call_api_post("dm.delete", roomId=room_id, kwargs=kwargs)

rocketchat_api-3.4.0/rocketchat_API/APISections/invites.py

@@ -0,0 +1,32 @@
+from rocketchat_API.APISections.base import RocketChatBase
+
+
+class RocketChatInvites(RocketChatBase):
+    def find_or_create_invite(self, rid, days, max_uses):
+        """
+        Creates or return an existing invite with the specified parameters.
+        Requires the create-invite-links permission
+        """
+        return self.call_api_post(
+            "findOrCreateInvite", rid=rid, days=days, maxUses=max_uses
+        )
+
+    def list_invites(self, **kwargs):
+        """Lists all of the invites on the server. Requires the create-invite-links permission."""
+        return self.call_api_get("listInvites", kwargs=kwargs)
+
+    def remove_invite(self, invite_id, **kwargs):
+        """Deletes an invite. Requires the create-invite-links permission."""
+        return self.call_api_delete("removeInvite/{}".format(invite_id))
+
+    def use_invite_token(self, token, **kwargs):
+        """Reports to the server that an invite token was used."""
+        return self.call_api_post("useInviteToken", token=token, kwargs=kwargs)
+
+    def validate_invite_token(self, token, **kwargs):
+        """Checks if an invite token is valid."""
+        return self.call_api_post("validateInviteToken", token=token, kwargs=kwargs)
+
+    def send_invitation_email(self, emails, **kwargs):
+        """Sends invitation emails to a list of email addresses."""
+        return self.call_api_post("sendInvitationEmail", emails=emails, kwargs=kwargs)

{rocketchat_api-3.2.0 → rocketchat_api-3.4.0}/rocketchat_API/APISections/livechat.py

@@ -70,3 +70,15 @@ class RocketChatLivechat(RocketChatBase):
         return self.call_api_get(
             "livechat/inquiries.getOne", roomId=room_id, kwargs=kwargs
         )
+
+    def livechat_get_appearance(self, **kwargs):
+        """Get the settings about the widget appearance. Permission required: view-livechat-manager"""
+        return self.call_api_get("livechat/appearance", kwargs=kwargs)
+
+    def livechat_set_appearance(self, settings):
+        """Update the livechat widget appearance settings. Permission required: view-livechat-manager
+
+        :param settings: list of dicts with '_id' and 'value' keys,
+                         e.g. [{"_id": "Livechat_title", "value": "Support"}]
+        """
+        return self.call_api_post("livechat/appearance", body=settings)

rocketchat_api-3.4.0/rocketchat_API/APISections/moderation.py

@@ -0,0 +1,67 @@
+from rocketchat_API.APISections.base import RocketChatBase, paginated
+
+
+class RocketChatModeration(RocketChatBase):
+    @paginated("reports")
+    def moderation_reports_by_users(self, **kwargs):
+        """Retrieves all the reported messages grouped by users. Permission required: view-moderation-console"""
+        return self.call_api_get("moderation.reportsByUsers", kwargs=kwargs)
+
+    @paginated("reports")
+    def moderation_user_reports(self, **kwargs):
+        """Get the list of reported users. Permission required: view-moderation-console"""
+        return self.call_api_get("moderation.userReports", kwargs=kwargs)
+
+    def moderation_user_reported_messages(self, user_id, **kwargs):
+        """Retrieve all reported messages of a user. Permission required: view-moderation-console"""
+        return self.call_api_get(
+            "moderation.user.reportedMessages", userId=user_id, kwargs=kwargs
+        )
+
+    def moderation_user_reports_by_user_id(self, user_id, **kwargs):
+        """Get the details of a specific user's reports. Permission required: view-moderation-console"""
+        return self.call_api_get(
+            "moderation.user.reportsByUserId", userId=user_id, kwargs=kwargs
+        )
+
+    @paginated("reports")
+    def moderation_reports(self, msg_id, **kwargs):
+        """Retrieve all the reports of a single message. A message can have many reports. Permission required: view-moderation-console"""
+        return self.call_api_get("moderation.reports", msgId=msg_id, kwargs=kwargs)
+
+    def moderation_report_info(self, report_id, **kwargs):
+        """Get more details of a single report. Permission required: view-moderation-console"""
+        return self.call_api_get(
+            "moderation.reportInfo", reportId=report_id, kwargs=kwargs
+        )
+
+    def moderation_report_user(self, user_id, description, **kwargs):
+        """Report a user."""
+        return self.call_api_post(
+            "moderation.reportUser",
+            userId=user_id,
+            description=description,
+            kwargs=kwargs,
+        )
+
+    def moderation_dismiss_reports(self, user_id=None, msg_id=None, **kwargs):
+        """You can dismiss all the reports of a particular user by the userId. You can also dismiss the report of a message by the msgId. Permission required: manage-moderation-actions"""
+        if user_id:
+            return self.call_api_post(
+                "moderation.dismissReports", userId=user_id, kwargs=kwargs
+            )
+        return self.call_api_post(
+            "moderation.dismissReports", msgId=msg_id, kwargs=kwargs
+        )
+
+    def moderation_dismiss_user_reports(self, user_id, **kwargs):
+        """Dismiss a specific reported user from the list of reported users. Permission required: manage-moderation-actions"""
+        return self.call_api_post(
+            "moderation.dismissUserReports", userId=user_id, kwargs=kwargs
+        )
+
+    def moderation_user_delete_reported_messages(self, user_id, **kwargs):
+        """Delete all the reports of messages that belongs to user. Permission required: manage-moderation-actions"""
+        return self.call_api_post(
+            "moderation.user.deleteReportedMessages", userId=user_id, kwargs=kwargs
+        )

{rocketchat_api-3.2.0 → rocketchat_api-3.4.0}/rocketchat_API/APISections/roles.py

@@ -33,3 +33,11 @@ class RocketChatRoles(RocketChatBase):
     def roles_sync(self, updated_since):
         """Gets all the roles in the system which are updated after a given date."""
         return self.call_api_get("roles.sync", updatedSince=updated_since)
+
+    def roles_delete(self, role_id, **kwargs):
+        """Deletes a role. Permission required: access-permissions"""
+        return self.call_api_post("roles.delete", roleId=role_id, kwargs=kwargs)
+
+    def roles_get_users_in_public_roles(self, **kwargs):
+        """Gets the users that belong to any public role."""
+        return self.call_api_get("roles.getUsersInPublicRoles", kwargs=kwargs)

{rocketchat_api-3.2.0 → rocketchat_api-3.4.0}/rocketchat_API/rocketchat.py

@@ -12,6 +12,7 @@ from rocketchat_API.APISections.invites import RocketChatInvites
 from rocketchat_API.APISections.licenses import RocketChatLicenses
 from rocketchat_API.APISections.livechat import RocketChatLivechat
 from rocketchat_API.APISections.miscellaneous import RocketChatMiscellaneous
+from rocketchat_API.APISections.moderation import RocketChatModeration
 from rocketchat_API.APISections.permissions import RocketChatPermissions
 from rocketchat_API.APISections.roles import RocketChatRoles
 from rocketchat_API.APISections.rooms import RocketChatRooms
@@ -36,6 +37,7 @@ class RocketChat(
     RocketChatLicenses,
     RocketChatLivechat,
     RocketChatMiscellaneous,
+    RocketChatModeration,
     RocketChatPermissions,
     RocketChatRoles,
     RocketChatRooms,

{rocketchat_api-3.2.0 → rocketchat_api-3.4.0}/rocketchat_API.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rocketchat_API
-Version: 3.2.0
+Version: 3.4.0
 Summary: Python API wrapper for Rocket.Chat
 Author-email: "Jorge Alberto Díaz Orozco (Akiel)" <diazorozcoj@gmail.com>
 Maintainer-email: "Jorge Alberto Díaz Orozco (Akiel)" <diazorozcoj@gmail.com>
@@ -16,6 +16,7 @@ Provides-Extra: test
 Requires-Dist: black; extra == "test"
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pymongo; extra == "test"
 Requires-Dist: requests; extra == "test"
 Requires-Dist: semver; extra == "test"
 Dynamic: license-file

{rocketchat_api-3.2.0 → rocketchat_api-3.4.0}/rocketchat_API.egg-info/SOURCES.txt

@@ -41,6 +41,7 @@ rocketchat_API/APISections/invites.py
 rocketchat_API/APISections/licenses.py
 rocketchat_API/APISections/livechat.py
 rocketchat_API/APISections/miscellaneous.py
+rocketchat_API/APISections/moderation.py
 rocketchat_API/APISections/permissions.py
 rocketchat_API/APISections/roles.py
 rocketchat_API/APISections/rooms.py
@@ -64,6 +65,7 @@ tests/test_integrations.py
 tests/test_invites.py
 tests/test_licenses.py
 tests/test_livechat.py
+tests/test_moderation.py
 tests/test_paginated.py
 tests/test_permissions.py
 tests/test_roles.py

{rocketchat_api-3.2.0 → rocketchat_api-3.4.0}/rocketchat_API.egg-info/requires.txt

@@ -5,5 +5,6 @@ packaging
 black
 pytest
 pytest-cov
+pymongo
 requests
 semver

rocketchat_api-3.4.0/tests/test_banners.py

@@ -0,0 +1,62 @@
+from datetime import datetime, timezone
+
+import pytest
+from pymongo import MongoClient
+
+
+@pytest.fixture
+def test_banner():
+    """There's no add_banner method in the public API so we need to add the test data manually to mongodb"""
+    client = MongoClient("mongodb://127.0.0.1:27017/rocketchat?directConnection=true")
+    db = client["rocketchat"]
+    banner = {
+        "_id": "test-banner-api",
+        "platform": ["web"],
+        "roles": ["user"],
+        "startAt": datetime(2020, 1, 1, tzinfo=timezone.utc),
+        "expireAt": datetime(2030, 1, 1, tzinfo=timezone.utc),
+        "createdBy": "system",
+        "createdAt": datetime(2026, 1, 1, tzinfo=timezone.utc),
+        "active": True,
+        "surface": "banner",
+        "view": {
+            "appId": "banner-core",
+            "viewId": "test-banner-api",
+            "type": "banner",
+            "blocks": [{"type": "section", "text": {"type": "mrkdwn", "text": "Test"}}],
+        },
+    }
+    db["rocketchat_banner"].insert_one(banner)
+    yield banner
+    db["rocketchat_banner"].delete_one({"_id": "test-banner-api"})
+    db["rocketchat_banner_dismiss"].delete_many({"bannerId": "test-banner-api"})
+    client.close()
+
+
+def test_banners(logged_rocket, test_banner):
+    result = logged_rocket.banners(platform="web")
+    assert "banners" in result
+    try:
+        banner = next(b for b in result["banners"] if b["_id"] == "test-banner-api")
+    except StopIteration:
+        pytest.fail("Test banner not found in banners list")
+    assert banner["platform"] == test_banner["platform"]
+    assert banner["surface"] == test_banner["surface"]
+
+
+def test_banners_get_by_id(logged_rocket, test_banner):
+    result = logged_rocket.banners_get_by_id("test-banner-api", platform="web")
+    assert "banners" in result
+    banner = result["banners"][0]
+    assert banner["_id"] == "test-banner-api"
+    assert banner["platform"] == test_banner["platform"]
+    assert banner["roles"] == test_banner["roles"]
+    assert banner["surface"] == test_banner["surface"]
+    assert banner["view"]["appId"] == test_banner["view"]["appId"]
+    assert banner["view"]["blocks"] == test_banner["view"]["blocks"]
+
+
+def test_banners_dismiss(logged_rocket, test_banner):
+    logged_rocket.banners_dismiss("test-banner-api")
+    remaining = logged_rocket.banners(platform="web").get("banners", [])
+    assert not any(b["_id"] == "test-banner-api" for b in remaining)

{rocketchat_api-3.2.0 → rocketchat_api-3.4.0}/tests/test_chat.py

@@ -224,6 +224,109 @@ def test_chat_get_mentioned_messages(logged_rocket):
     assert mentioned_messages[0].get("msg") == "hello @user1"
 
 
+def test_chat_unfollow_message(logged_rocket):
+    message_id = (
+        logged_rocket.chat_post_message("hello", channel="GENERAL")
+        .get("message")
+        .get("_id")
+    )
+    logged_rocket.chat_follow_message(mid=message_id)
+    logged_rocket.chat_unfollow_message(mid=message_id)
+    followed_ids = [
+        m.get("_id")
+        for m in logged_rocket.chat_get_thread_messages(thread_msg_id=message_id)
+    ]
+    assert message_id not in followed_ids
+
+
+def test_chat_get_deleted_messages(logged_rocket):
+    message_id = (
+        logged_rocket.chat_post_message("to be deleted", channel="GENERAL")
+        .get("message")
+        .get("_id")
+    )
+    logged_rocket.chat_delete(room_id="GENERAL", msg_id=message_id)
+    deleted = list(
+        logged_rocket.chat_get_deleted_messages(
+            room_id="GENERAL", since="2000-01-01T00:00:00.000Z"
+        )
+    )
+    assert any(m.get("_id") == message_id for m in deleted)
+
+
+def test_chat_get_pinned_messages(logged_rocket):
+    message_id = (
+        logged_rocket.chat_post_message("pin me", channel="GENERAL")
+        .get("message")
+        .get("_id")
+    )
+    logged_rocket.chat_pin_message(message_id)
+    pinned = list(logged_rocket.chat_get_pinned_messages(room_id="GENERAL"))
+    assert len(pinned) > 0
+    for msg in pinned:
+        assert "_id" in msg
+
+
+def test_chat_ignore_user(logged_rocket):
+    logged_rocket.chat_ignore_user(rid="GENERAL", user_id="rocket.cat")
+    logged_rocket.chat_ignore_user(rid="GENERAL", user_id="rocket.cat", ignore=False)
+
+
+def test_chat_sync_messages(logged_rocket):
+    logged_rocket.chat_post_message("sync test", channel="GENERAL")
+    result = logged_rocket.chat_sync_messages(
+        room_id="GENERAL", last_update="2000-01-01T00:00:00.000Z"
+    )
+    assert "result" in result
+
+
+def test_chat_get_threads_list(logged_rocket):
+    threads = list(logged_rocket.chat_get_threads_list(rid="GENERAL"))
+    for thread in threads:
+        assert "_id" in thread
+
+
+def test_chat_sync_thread_list(logged_rocket):
+    result = logged_rocket.chat_sync_thread_list(
+        rid="GENERAL", updated_since="2000-01-01T00:00:00.000Z"
+    )
+    assert "threads" in result
+
+
+def test_chat_sync_thread_messages(logged_rocket):
+    parent_id = (
+        logged_rocket.chat_post_message("thread parent", channel="GENERAL")
+        .get("message")
+        .get("_id")
+    )
+    logged_rocket.chat_post_message("reply", room_id="GENERAL", tmid=parent_id)
+    result = logged_rocket.chat_sync_thread_messages(
+        tmid=parent_id, updated_since="2000-01-01T00:00:00.000Z"
+    )
+    assert "messages" in result
+
+
+def test_chat_get_discussions(logged_rocket):
+    discussion = logged_rocket.rooms_create_discussion(
+        prid="GENERAL", t_name="test discussion"
+    )
+    discussion_id = discussion.get("discussion").get("_id")
+
+    try:
+        discussions = list(logged_rocket.chat_get_discussions(room_id="GENERAL"))
+        assert len(discussions) > 0
+        assert any(d.get("drid") == discussion_id for d in discussions)
+    finally:
+        logged_rocket.channels_delete(room_id=discussion_id)
+
+
+def test_chat_get_url_preview(logged_rocket):
+    result = logged_rocket.chat_get_url_preview(
+        room_id="GENERAL", url="https://www.w3schools.com/tags/movie.mp4"
+    )
+    assert "urlPreview" in result
+
+
 def test_chat_search(logged_rocket):
     logged_rocket.chat_post_message("unique_search_term_test", channel="GENERAL")
 

{rocketchat_api-3.2.0 → rocketchat_api-3.4.0}/tests/test_dms.py

@@ -158,3 +158,11 @@ def test_dm_list_everyone(logged_rocket):
     iterated_dms = list(logged_rocket.dm_list_everyone())
     for dm in iterated_dms:
         assert "_id" in dm
+
+
+def test_dm_delete(logged_rocket, recipient_user):
+    dm_create = logged_rocket.dm_create(recipient_user)
+    room_id = dm_create.get("room").get("_id")
+    logged_rocket.dm_delete(room_id)
+    room_ids = [dm.get("_id") for dm in logged_rocket.dm_list()]
+    assert room_id not in room_ids

rocketchat_api-3.4.0/tests/test_invites.py

@@ -0,0 +1,50 @@
+import pytest
+
+from rocketchat_API.APIExceptions.RocketExceptions import (
+    RocketApiException,
+    RocketBadStatusCodeException,
+)
+
+
+@pytest.fixture
+def invite(logged_rocket):
+    """Create an invite for GENERAL, yield it, then clean up."""
+    result = logged_rocket.find_or_create_invite(rid="GENERAL", days=7, max_uses=5)
+    yield result
+    try:
+        logged_rocket.remove_invite(result["_id"])
+    except (RocketApiException, RocketBadStatusCodeException):
+        pass
+
+
+def test_find_or_create_invite(invite):
+    assert invite.get("days") == 7
+    assert invite.get("maxUses") == 5
+    assert invite.get("rid") == "GENERAL"
+
+
+def test_list_invites(logged_rocket, invite):
+    list_invites = logged_rocket.list_invites()
+    assert isinstance(list_invites, list)
+    assert any(i["_id"] == invite["_id"] for i in list_invites)
+
+
+def test_remove_invite(logged_rocket, invite):
+    logged_rocket.remove_invite(invite["_id"])
+    list_invites = logged_rocket.list_invites()
+    assert not any(i["_id"] == invite["_id"] for i in list_invites)
+
+
+def test_validate_invite_token(logged_rocket, invite):
+    result = logged_rocket.validate_invite_token(token=invite["_id"])
+    assert result.get("valid") is True
+
+
+def test_use_invite_token(logged_rocket, invite):
+    result = logged_rocket.use_invite_token(token=invite["_id"])
+    assert "room" in result
+    assert result["room"]["rid"] == "GENERAL"
+
+
+def test_send_invitation_email(logged_rocket):
+    logged_rocket.send_invitation_email(emails=["test@example.com"])

{rocketchat_api-3.2.0 → rocketchat_api-3.4.0}/tests/test_livechat.py

@@ -125,3 +125,18 @@ def test_livechat_get_inquiries(logged_rocket, livechat_inquiry):
 def test_livechat_get_inquiries_non_existent_room(logged_rocket):
     inquiry_not_found = logged_rocket.livechat_inquiries_get_one(room_id="nonexistent")
     assert inquiry_not_found.get("inquiry") is None or "success" in inquiry_not_found
+
+
+def test_livechat_get_appearance(logged_rocket):
+    result = logged_rocket.livechat_get_appearance()
+    assert "appearance" in result
+
+
+def test_livechat_set_appearance(logged_rocket):
+    appearance = logged_rocket.livechat_get_appearance().get("appearance", [])
+    assert len(appearance) > 0, "Expected at least one appearance setting"
+
+    setting = appearance[0]
+    logged_rocket.livechat_set_appearance(
+        [{"_id": setting["_id"], "value": setting["value"]}]
+    )

rocketchat_api-3.4.0/tests/test_moderation.py

@@ -0,0 +1,135 @@
+import pytest
+
+from rocketchat_API.APIExceptions.RocketExceptions import (
+    RocketApiException,
+    RocketBadStatusCodeException,
+)
+
+
+@pytest.fixture
+def reported_message(logged_rocket):
+    """Post a message in GENERAL, report it, yield ids, then clean up."""
+    msg = logged_rocket.chat_post_message("message to report", channel="GENERAL").get(
+        "message"
+    )
+    msg_id = msg["_id"]
+    user_id = msg["u"]["_id"]
+    logged_rocket.chat_report_message(
+        message_id=msg_id, description="test moderation report"
+    )
+    reports = list(logged_rocket.moderation_reports(msg_id=msg_id))
+    report_id = reports[0]["_id"] if reports else None
+    yield {"msg_id": msg_id, "user_id": user_id, "report_id": report_id}
+    try:
+        logged_rocket.moderation_dismiss_reports(msg_id=msg_id, reason="cleanup")
+    except (RocketApiException, RocketBadStatusCodeException):
+        pass
+    try:
+        logged_rocket.chat_delete(room_id="GENERAL", msg_id=msg_id)
+    except (RocketApiException, RocketBadStatusCodeException):
+        pass
+
+
+@pytest.fixture
+def reported_user(logged_rocket):
+    """Report the logged-in user (self-report), yield user_id, then clean up."""
+    user_id = logged_rocket.me().get("_id")
+    logged_rocket.moderation_report_user(
+        user_id=user_id, description="test user report"
+    )
+    yield user_id
+    logged_rocket.moderation_dismiss_user_reports(user_id=user_id, reason="cleanup")
+
+
+def test_moderation_reports(logged_rocket, reported_message):
+    reports = list(logged_rocket.moderation_reports(msg_id=reported_message["msg_id"]))
+    assert len(reports) > 0
+    report = reports[0]
+    assert report["_id"] == reported_message["report_id"]
+    assert "description" in report
+    assert "reportedBy" in report
+    assert "room" in report
+
+
+def test_moderation_report_info(logged_rocket, reported_message):
+    result = logged_rocket.moderation_report_info(
+        report_id=reported_message["report_id"]
+    )
+    assert result["report"]["_id"] == reported_message["report_id"]
+    assert result["report"]["room"]["_id"] == "GENERAL"
+
+
+def test_moderation_reports_by_users(logged_rocket, reported_message):
+    reports = list(logged_rocket.moderation_reports_by_users())
+    assert len(reports) > 0
+    assert any(r["userId"] == reported_message["user_id"] for r in reports)
+
+
+def test_moderation_user_reported_messages(logged_rocket, reported_message):
+    result = logged_rocket.moderation_user_reported_messages(
+        user_id=reported_message["user_id"]
+    )
+    assert "messages" in result
+    assert len(result["messages"]) > 0
+    assert result["user"]["_id"] == reported_message["user_id"]
+    assert any(
+        m["message"]["_id"] == reported_message["msg_id"] for m in result["messages"]
+    )
+
+
+def test_moderation_report_user(logged_rocket, reported_user):
+    reports = list(logged_rocket.moderation_user_reports())
+    assert len(reports) > 0
+    assert any(r["reportedUser"]["_id"] == reported_user for r in reports)
+
+
+def test_moderation_user_reports(logged_rocket, reported_user):
+    reports = list(logged_rocket.moderation_user_reports())
+    assert len(reports) > 0
+    report = reports[0]
+    assert "reportedUser" in report
+    assert "ts" in report
+    assert "count" in report
+
+
+def test_moderation_user_reports_by_user_id(logged_rocket, reported_user):
+    result = logged_rocket.moderation_user_reports_by_user_id(user_id=reported_user)
+    assert result["user"]["_id"] == reported_user
+    assert "reports" in result
+    assert len(result["reports"]) > 0
+
+
+def test_moderation_dismiss_reports_by_msg(logged_rocket, reported_message):
+    logged_rocket.moderation_dismiss_reports(msg_id=reported_message["msg_id"])
+    reports = list(logged_rocket.moderation_reports(msg_id=reported_message["msg_id"]))
+    assert len(reports) == 0
+
+
+def test_moderation_dismiss_reports_by_user(logged_rocket, reported_message):
+    logged_rocket.moderation_dismiss_reports(user_id=reported_message["user_id"])
+    reports = list(logged_rocket.moderation_reports_by_users())
+    assert not any(r["userId"] == reported_message["user_id"] for r in reports)
+
+
+def test_moderation_dismiss_user_reports(logged_rocket, reported_user):
+    logged_rocket.moderation_dismiss_user_reports(user_id=reported_user)
+    reports = list(logged_rocket.moderation_user_reports())
+    assert not any(r["reportedUser"]["_id"] == reported_user for r in reports)
+
+
+def test_moderation_user_delete_reported_messages(logged_rocket):
+    msg = logged_rocket.chat_post_message(
+        "message to delete via moderation", channel="GENERAL"
+    ).get("message")
+    msg_id = msg["_id"]
+    user_id = msg["u"]["_id"]
+    logged_rocket.chat_report_message(
+        message_id=msg_id, description="report before delete"
+    )
+    logged_rocket.moderation_user_delete_reported_messages(user_id=user_id)
+    deleted = list(
+        logged_rocket.chat_get_deleted_messages(
+            room_id="GENERAL", since="2000-01-01T00:00:00.000Z"
+        )
+    )
+    assert any(m["_id"] == msg_id for m in deleted)

{rocketchat_api-3.2.0 → rocketchat_api-3.4.0}/tests/test_roles.py

@@ -50,3 +50,21 @@ def test_roles_get_users_in_role(logged_rocket):
 def test_roles_sync(logged_rocket):
     roles_sync = logged_rocket.roles_sync(updated_since="2017-11-25T15:08:17.248Z")
     assert len(roles_sync.get("roles")) > 0
+
+
+def test_roles_delete(logged_rocket, skip_if_no_license):
+    name = str(uuid.uuid1())
+    role_id = logged_rocket.roles_create(name=name).get("role").get("_id")
+    logged_rocket.roles_delete(role_id=role_id)
+    roles = logged_rocket.roles_list().get("roles", [])
+    assert not any(r["_id"] == role_id for r in roles)
+
+
+def test_roles_get_users_in_public_roles(logged_rocket):
+    result = logged_rocket.roles_get_users_in_public_roles()
+    assert "users" in result
+    assert len(result["users"]) > 0
+    user = result["users"][0]
+    assert "_id" in user
+    assert "username" in user
+    assert "roles" in user

rocketchat_api-3.2.0/rocketchat_API/APISections/banners.py

@@ -1,11 +0,0 @@
-from rocketchat_API.APISections.base import RocketChatBase
-
-
-class RocketChatBanners(RocketChatBase):
-    def banners(self, platform, **kwargs):
-        """Gets the banner to be shown to the authenticated user"""
-        return self.call_api_get(
-            "banners",
-            platform=platform,
-            kwargs=kwargs,
-        )

rocketchat_api-3.2.0/rocketchat_API/APISections/invites.py

@@ -1,16 +0,0 @@
-from rocketchat_API.APISections.base import RocketChatBase
-
-
-class RocketChatInvites(RocketChatBase):
-    def find_or_create_invite(self, rid, days, max_uses):
-        """
-        Creates or return an existing invite with the specified parameters.
-        Requires the create-invite-links permission
-        """
-        return self.call_api_post(
-            "findOrCreateInvite", rid=rid, days=days, maxUses=max_uses
-        )
-
-    def list_invites(self, **kwargs):
-        """Lists all of the invites on the server. Requires the create-invite-links permission."""
-        return self.call_api_get("listInvites", kwargs=kwargs)

rocketchat_api-3.2.0/tests/test_banners.py

@@ -1,3 +0,0 @@
-def test_banners(logged_rocket):
-    banners = logged_rocket.banners(platform="web")
-    assert "banners" in banners

rocketchat_api-3.2.0/tests/test_invites.py

@@ -1,12 +0,0 @@
-def test_find_or_create_invite(logged_rocket):
-    rid = "GENERAL"
-    find_or_create_invite = logged_rocket.find_or_create_invite(
-        rid=rid, days=7, max_uses=5
-    )
-    assert find_or_create_invite.get("days") == 7
-    assert find_or_create_invite.get("maxUses") == 5
-
-
-def test_list_invites(logged_rocket):
-    list_invites = logged_rocket.list_invites()
-    assert isinstance(list_invites, list)