fix integration tests

Author: MHHukiewitz

src/aleph/sdk/client.py

@@ -475,6 +475,7 @@ async def fetch_aggregate(self, address: str, key: str) -> Dict[str, Dict]:
         async with self.http_session.get(
             f"/api/v0/aggregates/{address}.json", params=params
         ) as resp:
+            resp.raise_for_status()
             result = await resp.json()
             data = result.get("data", dict())
             return data.get(key)
@@ -491,6 +492,7 @@ async def fetch_aggregates(
             f"/api/v0/aggregates/{address}.json",
             params=params,
         ) as resp:
+            resp.raise_for_status()
             result = await resp.json()
             data = result.get("data", dict())
             return data

tests/integration/config.py

@@ -1,3 +1,3 @@
-TARGET_NODE = "http://163.172.70.92:4024"
+TARGET_NODE = "https://api1.aleph.im"
 REFERENCE_NODE = "https://api2.aleph.im"
 TEST_CHANNEL = "INTEGRATION_TESTS"

tests/integration/itest_forget.py

@@ -1,5 +1,3 @@
-from typing import Callable, Dict
-
 import pytest
 from aleph_message.models import PostMessage
 
@@ -14,21 +12,6 @@
 async def create_and_forget_post(
     account: Account, emitter_node: str, receiver_node: str, channel=TEST_CHANNEL
 ) -> str:
-    async def wait_matching_posts(
-        item_hash: str,
-        condition: Callable[[Dict], bool],
-        timeout: int = 5,
-    ):
-        async with AuthenticatedAlephClient(
-            account=account, api_server=receiver_node
-        ) as rx_session:
-            return await try_until(
-                rx_session.get_posts,
-                condition,
-                timeout=timeout,
-                hashes=[item_hash],
-            )
-
     async with AuthenticatedAlephClient(
         account=account, api_server=emitter_node
     ) as tx_session:
@@ -38,13 +21,17 @@ async def wait_matching_posts(
             channel="INTEGRATION_TESTS",
         )
 
-    # Wait for the message to appear on the receiver. We don't check the values,
-    # they're checked in other integration tests.
-    get_post_response = await wait_matching_posts(
-        post_message.item_hash,
-        lambda response: len(response["posts"]) > 0,
-    )
-    print(get_post_response)
+    async with AuthenticatedAlephClient(
+        account=account, api_server=receiver_node
+    ) as rx_session:
+        await try_until(
+            rx_session.get_messages,
+            lambda response: len(response.messages) > 0,
+            timeout=5,
+            message_filter=MessageFilter(
+                hashes=[post_message.item_hash],
+            ),
+        )
 
     post_hash = post_message.item_hash
     reason = "This well thought-out content offends me!"
@@ -56,24 +43,40 @@ async def wait_matching_posts(
             reason=reason,
             channel=channel,
         )
-
     assert forget_message.sender == account.get_address()
     assert forget_message.content.reason == reason
     assert forget_message.content.hashes == [post_hash]
 
-    print(forget_message)
-
     # Wait until the message is forgotten
-    forgotten_posts = await wait_matching_posts(
-        post_hash,
-        lambda response: "forgotten_by" in response["posts"][0],
-        timeout=15,
-    )
-
-    assert len(forgotten_posts["posts"]) == 1
-    forgotten_post = forgotten_posts["posts"][0]
-    assert forgotten_post["forgotten_by"] == [forget_message.item_hash]
-    assert forgotten_post["item_content"] is None
+    async with AuthenticatedAlephClient(
+        account=account, api_server=receiver_node
+    ) as rx_session:
+        await try_until(
+            rx_session.get_messages,
+            lambda response: len(response.messages) > 0,
+            timeout=5,
+            message_filter=MessageFilter(
+                hashes=[forget_message.item_hash],
+            ),
+        )
+
+    async with AuthenticatedAlephClient(
+        account=account, api_server=receiver_node
+    ) as rx_session:
+        forgotten_messages = await try_until(
+            rx_session.get_messages,
+            lambda response: len(response.messages) == 0,
+            timeout=5,
+            message_filter=MessageFilter(
+                hashes=[post_hash],
+            ),
+        )
+    # TODO: Should we now receive any messages? It seems they are completely gone
+
+    assert len(forgotten_messages.messages) == 1
+    forgotten_post = forgotten_messages.messages[0]
+    assert forgotten_post.forgotten_by == [forget_message.item_hash]
+    assert forgotten_post.item_content is None
     print(forgotten_post)
 
     return post_hash

tests/integration/itest_posts.py

@@ -1,38 +1,35 @@
 import pytest
-from aleph_message.models import MessagesResponse
 
 from aleph.sdk.client import AuthenticatedAlephClient
+from aleph.sdk.models.message import MessageFilter
 from tests.integration.toolkit import try_until
 
 from .config import REFERENCE_NODE, TARGET_NODE
 
 
-async def create_message_on_target(
-    fixture_account, emitter_node: str, receiver_node: str
-):
+async def create_message_on_target(account, emitter_node: str, receiver_node: str):
     """
     Create a POST message on the target node, then fetch it from the reference node.
     """
     async with AuthenticatedAlephClient(
-        account=fixture_account, api_server=emitter_node
+        account=account, api_server=emitter_node
     ) as tx_session:
         post_message, message_status = await tx_session.create_post(
             post_content=None,
             post_type="POST",
             channel="INTEGRATION_TESTS",
         )
 
-    def response_contains_messages(response: MessagesResponse) -> bool:
-        return len(response.messages) > 0
-
     async with AuthenticatedAlephClient(
-        account=fixture_account, api_server=receiver_node
+        account=account, api_server=receiver_node
     ) as rx_session:
         responses = await try_until(
             rx_session.get_messages,
-            response_contains_messages,
+            lambda response: len(response.messages) > 0,
             timeout=5,
-            hashes=[post_message.item_hash],
+            message_filter=MessageFilter(
+                hashes=[post_message.item_hash],
+            ),
         )
 
     message_from_target = responses.messages[0]

tests/integration/toolkit.py

@@ -9,7 +9,7 @@ async def try_until(
     coroutine: Callable[..., Awaitable[T]],
     condition: Callable[[T], bool],
     timeout: float,
-    time_between_attempts: float = 0.5,
+    time_between_attempts: float = 1,
     *args,
     **kwargs,
 ) -> T: