Feature: Search improvements (#63)

Author: miagilepner

stream_chat/async_chat/client.py

@@ -309,8 +309,11 @@ async def get_rate_limits(
 
         return await self.get("rate_limits", params)
 
-    async def search(self, filter_conditions, query, **options):
-        params = {**options, "filter_conditions": filter_conditions, "query": query}
+    async def search(self, filter_conditions, query, sort=None, **options):
+        if "offset" in options:
+            if sort or "next" in options:
+                raise ValueError("cannot use offset with sort or next parameters")
+        params = self.create_search_params(filter_conditions, query, sort, **options)
         return await self.get("search", params={"payload": json.dumps(params)})
 
     async def send_file(self, uri, url, name, user, content_type=None):

stream_chat/base/client.py

@@ -46,6 +46,17 @@ def create_token(self, user_id, exp=None, iat=None, **claims):
             payload["iat"] = iat
         return jwt.encode(payload, self.api_secret, algorithm="HS256")
 
+    def create_search_params(self, filter_conditions, query, sort, **options):
+        params = options.copy()
+        if isinstance(query, str):
+            params.update({"query": query})
+        else:
+            params.update({"message_filter_conditions": query})
+        params.update(
+            {"filter_conditions": filter_conditions, "sort": self.normalize_sort(sort)}
+        )
+        return params
+
     def verify_webhook(self, request_body, x_signature):
         """
         Verify the signature added to a webhook event

stream_chat/client.py

@@ -304,8 +304,11 @@ def get_rate_limits(
 
         return self.get("rate_limits", params)
 
-    def search(self, filter_conditions, query, **options):
-        params = {**options, "filter_conditions": filter_conditions, "query": query}
+    def search(self, filter_conditions, query, sort=None, **options):
+        if "offset" in options:
+            if sort or "next" in options:
+                raise ValueError("cannot use offset with sort or next parameters")
+        params = self.create_search_params(filter_conditions, query, sort, **options)
         return self.get("search", params={"payload": json.dumps(params)})
 
     def send_file(self, uri, url, name, user, content_type=None):

stream_chat/tests/async_chat/test_client.py

@@ -10,7 +10,6 @@
 from stream_chat.base.exceptions import StreamAPIException
 
 
-@pytest.mark.incremental
 class TestClient(object):
     def test_normalize_sort(self, client):
         expected = [
@@ -315,8 +314,36 @@ async def test_get_rate_limits(self, event_loop, client):
             > response["server_side"]["GetRateLimits"]["remaining"]
         )
 
+    @pytest.mark.xfail
     @pytest.mark.asyncio
-    async def test_search(self, event_loop, client, channel, random_user):
+    async def test_search_with_sort(self, client, channel, random_user):
+        text = str(uuid.uuid4())
+        ids = ["0" + text, "1" + text]
+        await channel.send_message(
+            {"text": text, "id": ids[0]},
+            random_user["id"],
+        )
+        await channel.send_message(
+            {"text": text, "id": ids[1]},
+            random_user["id"],
+        )
+        response = await client.search(
+            {"type": "messaging"}, text, **{"limit": 1, "sort": [{"created_at": -1}]}
+        )
+        # searches all channels so make sure at least one is found
+        assert len(response["results"]) >= 1
+        assert response["next"] is not None
+        assert ids[1] == response["results"][0]["message"]["id"]
+        response = await client.search(
+            {"type": "messaging"}, text, **{"limit": 1, "next": response["next"]}
+        )
+        assert len(response["results"]) >= 1
+        assert response["previous"] is not None
+        assert response["next"] is None
+        assert ids[0] == response["results"][0]["message"]["id"]
+
+    @pytest.mark.asyncio
+    async def test_search(self, client, channel, random_user):
         query = "supercalifragilisticexpialidocious"
         await channel.send_message(
             {"text": f"How many syllables are there in {query}?"},
@@ -337,6 +364,45 @@ async def test_search(self, event_loop, client, channel, random_user):
         for message in response["results"]:
             assert query not in message["message"]["text"]
 
+    @pytest.mark.asyncio
+    async def test_search_message_filters(self, client, channel, random_user):
+        query = "supercalifragilisticexpialidocious"
+        await channel.send_message(
+            {"text": f"How many syllables are there in {query}?"},
+            random_user["id"],
+        )
+        await channel.send_message(
+            {"text": "Does 'cious' count as one or two?"}, random_user["id"]
+        )
+        response = await client.search(
+            {"type": "messaging"},
+            {"text": {"$q": query}},
+            **{
+                "limit": 2,
+                "offset": 0,
+            },
+        )
+        assert len(response["results"]) >= 1
+        assert query in response["results"][0]["message"]["text"]
+
+    @pytest.mark.asyncio
+    async def test_search_offset_with_sort(self, client):
+        query = "supercalifragilisticexpialidocious"
+        with pytest.raises(ValueError):
+            await client.search(
+                {"type": "messaging"},
+                query,
+                **{"limit": 2, "offset": 1, "sort": [{"created_at": -1}]},
+            )
+
+    @pytest.mark.asyncio
+    async def test_search_offset_with_next(self, client):
+        query = "supercalifragilisticexpialidocious"
+        with pytest.raises(ValueError):
+            await client.search(
+                {"type": "messaging"}, query, **{"limit": 2, "offset": 1, "next": query}
+            )
+
     @pytest.mark.asyncio
     async def test_query_channels_members_in(
         self, event_loop, client, fellowship_of_the_ring

stream_chat/tests/test_client.py

@@ -10,7 +10,6 @@
 from stream_chat.base.exceptions import StreamAPIException
 
 
-@pytest.mark.incremental
 class TestClient(object):
     def test_normalize_sort(self, client):
         expected = [
@@ -258,6 +257,33 @@ def test_get_rate_limits(self, client):
             > response["server_side"]["GetRateLimits"]["remaining"]
         )
 
+    @pytest.mark.xfail
+    def test_search_with_sort(self, client, channel, random_user):
+        text = str(uuid.uuid4())
+        ids = ["0" + text, "1" + text]
+        channel.send_message(
+            {"text": text, "id": ids[0]},
+            random_user["id"],
+        )
+        channel.send_message(
+            {"text": text, "id": ids[1]},
+            random_user["id"],
+        )
+        response = client.search(
+            {"type": "messaging"}, text, **{"limit": 1, "sort": [{"created_at": -1}]}
+        )
+        # searches all channels so make sure at least one is found
+        assert len(response["results"]) >= 1
+        assert response["next"] is not None
+        assert ids[1] == response["results"][0]["message"]["id"]
+        response = client.search(
+            {"type": "messaging"}, text, **{"limit": 1, "next": response["next"]}
+        )
+        assert len(response["results"]) >= 1
+        assert response["previous"] is not None
+        assert response["next"] is None
+        assert ids[0] == response["results"][0]["message"]["id"]
+
     def test_search(self, client, channel, random_user):
         query = "supercalifragilisticexpialidocious"
         channel.send_message(
@@ -279,6 +305,42 @@ def test_search(self, client, channel, random_user):
         for message in response["results"]:
             assert query not in message["message"]["text"]
 
+    def test_search_message_filters(self, client, channel, random_user):
+        query = "supercalifragilisticexpialidocious"
+        channel.send_message(
+            {"text": f"How many syllables are there in {query}?"},
+            random_user["id"],
+        )
+        channel.send_message(
+            {"text": "Does 'cious' count as one or two?"}, random_user["id"]
+        )
+        response = client.search(
+            {"type": "messaging"},
+            {"text": {"$q": query}},
+            **{
+                "limit": 2,
+                "offset": 0,
+            },
+        )
+        assert len(response["results"]) >= 1
+        assert query in response["results"][0]["message"]["text"]
+
+    def test_search_offset_with_sort(self, client):
+        query = "supercalifragilisticexpialidocious"
+        with pytest.raises(ValueError):
+            client.search(
+                {"type": "messaging"},
+                query,
+                **{"limit": 2, "offset": 1, "sort": [{"created_at": -1}]},
+            )
+
+    def test_search_offset_with_next(self, client):
+        query = "supercalifragilisticexpialidocious"
+        with pytest.raises(ValueError):
+            client.search(
+                {"type": "messaging"}, query, **{"limit": 2, "offset": 1, "next": query}
+            )
+
     def test_query_channels_members_in(self, client, fellowship_of_the_ring):
         response = client.query_channels({"members": {"$in": ["gimli"]}}, {"id": 1})
         assert len(response["channels"]) == 1