Add tests for exports (#72)

Author: ferhatelmas

stream_chat/async_chat/client.py

@@ -581,12 +581,17 @@ async def revoke_users_token(self, user_ids, before):
             )
         await self.update_users_partial(updates)
 
-    async def export_channel(self, channel_id: str, channel_type: str, messages_since: str = None,
-                             messages_until=None):
+    async def export_channel(
+        self,
+        channel_type,
+        channel_id,
+        messages_since=None,
+        messages_until=None,
+    ):
         """
         Requests a channel export
-        :param channel_id: channel_id of channel which needs to be exported
         :param channel_type: channel_type of channel which needs to be exported
+        :param channel_id: channel_id of channel which needs to be exported
         :param messages_since: RFC-3339 string or datetime to filter messages since that time, optional
         :param messages_until: RFC-3339 string or datetime to filter messages until that time, optional
         :type channel_id: str
@@ -605,22 +610,22 @@ async def export_channel(self, channel_id: str, channel_type: str, messages_sinc
                     "id": channel_id,
                     "type": channel_type,
                     "messages_since": messages_since,
-                    "messages_until": messages_until
+                    "messages_until": messages_until,
                 }
             ]
         )
 
-    async def export_channels(self, channels_data: list):
+    async def export_channels(self, channels):
         """
         Requests a channels export
         :param channels_data: list of channel's data which need to be exported with keys:
-        - `channel_id`: str
         - `channel_type`: str
+        - `channel_id`: str
         - `messages_since` (optional, nullable): str
         - `messages_until` (optional, nullable): str
         :type channels_data: List[Dict[str, str]]
         """
-        return await self.post("export_channels", data={"channels": channels_data})
+        return await self.post("export_channels", data={"channels": channels})
 
     async def get_export_channel_status(self, task_id: str):
         """

stream_chat/base/client.py

@@ -549,22 +549,23 @@ def revoke_users_token(self, user_ids, since):
         pass
 
     @abc.abstractmethod
-    def export_channel(self, channel_id: str, channel_type: str, messages_since: str = None,
-                       messages_until=None):
+    def export_channel(
+        self, channel_type, channel_id, messages_since=None, messages_until=None
+    ):
         """
         Requests a channel export
         """
         pass
 
     @abc.abstractmethod
-    def export_channels(self, channels_data: list):
+    def export_channels(self, channels):
         """
         Requests a channels export
         """
         pass
 
     @abc.abstractmethod
-    def get_export_channel_status(self, task_id: str):
+    def get_export_channel_status(self, task_id):
         """
         Retrieves status of export
         """

stream_chat/client.py

@@ -573,16 +573,21 @@ def revoke_users_token(self, user_ids, before):
             )
         self.update_users_partial(updates)
 
-    def export_channel(self, channel_id: str, channel_type: str, messages_since: str = None,
-                       messages_until=None):
+    def export_channel(
+        self,
+        channel_type,
+        channel_id,
+        messages_since=None,
+        messages_until=None,
+    ):
         """
         Requests a channel export
-        :param channel_id: channel_id of channel which needs to be exported
         :param channel_type: channel_type of channel which needs to be exported
+        :param channel_id: channel_id of channel which needs to be exported
         :param messages_since: RFC-3339 string or datetime to filter messages since that time, optional
         :param messages_until: RFC-3339 string or datetime to filter messages until that time, optional
-        :type channel_id: str
         :type channel_type: str
+        :type channel_id: str
         :type messages_since: Union[str, datetime.datetime]
         :type messages_until: Union[str, datetime.datetime]
         """
@@ -597,24 +602,24 @@ def export_channel(self, channel_id: str, channel_type: str, messages_since: str
                     "id": channel_id,
                     "type": channel_type,
                     "messages_since": messages_since,
-                    "messages_until": messages_until
+                    "messages_until": messages_until,
                 }
             ]
         )
 
-    def export_channels(self, channels_data: list):
+    def export_channels(self, channels):
         """
         Requests a channels export
-        :param channels_data: list of channel's data which need to be exported with keys:
-        - `channel_id`: str
+        :param channels: list of channel's data which need to be exported with keys:
         - `channel_type`: str
+        - `channel_id`: str
         - `messages_since` (optional, nullable): str
         - `messages_until` (optional, nullable): str
-        :type channels_data: List[Dict[str, str]]
+        :type channels: List[Dict[str, str]]
         """
-        return self.post("export_channels", data={"channels": channels_data})
+        return self.post("export_channels", data={"channels": channels})
 
-    def get_export_channel_status(self, task_id: str):
+    def get_export_channel_status(self, task_id):
         """
         Retrieves status of export
         :param task_id: task_id of task which status needs to be retrieved

stream_chat/tests/async_chat/test_channel.py

@@ -1,4 +1,5 @@
 import uuid
+import time
 import pytest
 
 from stream_chat.base.exceptions import StreamAPIException
@@ -298,3 +299,31 @@ async def test_mute_umute(self, event_loop, client, channel, random_users):
             user_id=user_id,
         )
         assert len(response["channels"]) == 0
+
+    @pytest.mark.asyncio
+    async def test_export_channel_status(self, client, channel):
+        with pytest.raises(StreamAPIException, match=r".*Can't find task.*"):
+            await client.get_export_channel_status(str(uuid.uuid4()))
+
+        with pytest.raises(StreamAPIException, match=r".*Can't find channel.*"):
+            await client.export_channel("messaging", str(uuid.uuid4()))
+
+    @pytest.mark.asyncio
+    async def test_export_channel(self, client, channel, random_users):
+        await channel.send_message({"text": "Hey Joni"}, random_users[0]["id"])
+
+        resp = await client.export_channel(channel.channel_type, channel.id)
+        task_id = resp["task_id"]
+        assert task_id != ""
+
+        while True:
+            resp = await client.get_export_channel_status(task_id)
+            assert resp["status"] != ""
+            assert resp["created_at"] != ""
+            assert resp["updated_at"] != ""
+            if resp["status"] == "completed":
+                assert len(resp["result"]) != 0
+                assert resp["result"]["url"] != ""
+                assert len(resp["error"]) != 0
+                break
+            time.sleep(0.5)

stream_chat/tests/test_channel.py

@@ -1,4 +1,5 @@
 import uuid
+import time
 
 import pytest
 
@@ -263,7 +264,6 @@ def test_mute_unmute(self, client, channel, random_users):
         response = client.query_channels(
             {"muted": True, "cid": channel.cid}, user_id=user_id
         )
-        print(response, channel.cid)
         assert len(response["channels"]) == 1
 
         channel.unmute(user_id)
@@ -272,3 +272,29 @@ def test_mute_unmute(self, client, channel, random_users):
             user_id=user_id,
         )
         assert len(response["channels"]) == 0
+
+    def test_export_channel_status(self, client, channel):
+        with pytest.raises(StreamAPIException, match=r".*Can't find task.*"):
+            client.get_export_channel_status(str(uuid.uuid4()))
+
+        with pytest.raises(StreamAPIException, match=r".*Can't find channel.*"):
+            client.export_channel("messaging", str(uuid.uuid4()))
+
+    def test_export_channel(self, client, channel, random_users):
+        channel.send_message({"text": "Hey Joni"}, random_users[0]["id"])
+
+        resp = client.export_channel(channel.channel_type, channel.id)
+        task_id = resp["task_id"]
+        assert task_id != ""
+
+        while True:
+            resp = client.get_export_channel_status(task_id)
+            assert resp["status"] != ""
+            assert resp["created_at"] != ""
+            assert resp["updated_at"] != ""
+            if resp["status"] == "completed":
+                assert len(resp["result"]) != 0
+                assert resp["result"]["url"] != ""
+                assert len(resp["error"]) != 0
+                break
+            time.sleep(0.5)