Fix: Integration tests fail after changes to client and node behavior; aggregate fetching could result in unhandled parsing errors

Solution: Adjust integration tests for current functionality; add raise_for_status to GET aggregates requests

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,34 +1,20 @@
-from typing import Callable, Dict
+import asyncio
+from typing import Tuple
 
 import pytest
-from aleph_message.models import PostMessage
+from aleph_message.models import ItemHash
 
 from aleph.sdk.client import AuthenticatedAlephClient
 from aleph.sdk.models.message import MessageFilter
 from aleph.sdk.types import Account
 
 from .config import REFERENCE_NODE, TARGET_NODE, TEST_CHANNEL
-from .toolkit import try_until
+from .toolkit import has_messages, has_no_messages, try_until
 
 
 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],
-            )
-
+) -> Tuple[ItemHash, ItemHash]:
     async with AuthenticatedAlephClient(
         account=account, api_server=emitter_node
     ) as tx_session:
@@ -38,13 +24,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,
+            has_messages,
+            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,27 +46,34 @@ 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)
+    forget_hash = forget_message.item_hash
 
     # Wait until the message is forgotten
-    forgotten_posts = await wait_matching_posts(
-        post_hash,
-        lambda response: "forgotten_by" in response["posts"][0],
-        timeout=15,
-    )
+    async with AuthenticatedAlephClient(
+        account=account, api_server=receiver_node
+    ) as rx_session:
+        await try_until(
+            rx_session.get_messages,
+            has_messages,
+            timeout=5,
+            message_filter=MessageFilter(
+                hashes=[forget_hash],
+            ),
+        )
 
-    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
-    print(forgotten_post)
+        await try_until(
+            rx_session.get_messages,
+            has_no_messages,
+            timeout=5,
+            message_filter=MessageFilter(
+                hashes=[post_hash],
+            ),
+        )
 
-    return post_hash
+    return post_hash, forget_hash
 
 
 @pytest.mark.asyncio
@@ -85,7 +82,7 @@ async def test_create_and_forget_post_on_target(fixture_account):
     Create a post on the target node, then forget it and check that the change is propagated
     to the reference node.
     """
-    _ = await create_and_forget_post(fixture_account, TARGET_NODE, REFERENCE_NODE)
+    _, _ = await create_and_forget_post(fixture_account, TARGET_NODE, REFERENCE_NODE)
 
 
 @pytest.mark.asyncio
@@ -94,7 +91,7 @@ async def test_create_and_forget_post_on_reference(fixture_account):
     Create a post on the reference node, then forget it and check that the change is propagated
     to the target node.
     """
-    _ = await create_and_forget_post(fixture_account, REFERENCE_NODE, TARGET_NODE)
+    _, _ = await create_and_forget_post(fixture_account, REFERENCE_NODE, TARGET_NODE)
 
 
 @pytest.mark.asyncio
@@ -104,26 +101,33 @@ async def test_forget_a_forget_message(fixture_account):
     """
 
     # TODO: this test should be moved to the PyAleph API tests, once a framework is in place.
-    post_hash = await create_and_forget_post(fixture_account, TARGET_NODE, TARGET_NODE)
+    post_hash, forget_hash = await create_and_forget_post(
+        fixture_account, TARGET_NODE, REFERENCE_NODE
+    )
     async with AuthenticatedAlephClient(
         account=fixture_account, api_server=TARGET_NODE
-    ) as session:
-        get_post_message: PostMessage = await session.get_message(post_hash)
-
-        forget_message_hash = get_post_message.forgotten_by[0]
-        forget_message, forget_status = await session.forget(
-            hashes=[forget_message_hash],
+    ) as tx_session:
+        forget_message, forget_status = await tx_session.forget(
+            hashes=[forget_hash],
             reason="I want to remember this post. Maybe I can forget I forgot it?",
             channel=TEST_CHANNEL,
         )
 
         print(forget_message)
 
-        get_forget_message_response = await session.get_messages(
+    # wait 5 seconds
+    await asyncio.sleep(5)
+
+    async with AuthenticatedAlephClient(
+        account=fixture_account, api_server=REFERENCE_NODE
+    ) as rx_session:
+        get_forget_message_response = await try_until(
+            rx_session.get_messages,
+            has_messages,
+            timeout=5,
             message_filter=MessageFilter(
-                hashes=[forget_message_hash],
-                channels=[TEST_CHANNEL],
-            )
+                hashes=[forget_hash],
+            ),
         )
         assert len(get_forget_message_response.messages) == 1
         forget_message = get_forget_message_response.messages[0]

tests/integration/itest_posts.py

@@ -1,38 +1,35 @@
 import pytest
-from aleph_message.models import MessagesResponse
 
 from aleph.sdk.client import AuthenticatedAlephClient
-from tests.integration.toolkit import try_until
+from aleph.sdk.models.message import MessageFilter
+from tests.integration.toolkit import has_messages, 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,
+            has_messages,
             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

@@ -2,14 +2,16 @@
 import time
 from typing import Awaitable, Callable, TypeVar
 
+from aleph.sdk.models.message import MessagesResponse
+
 T = TypeVar("T")
 
 
 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:
@@ -23,3 +25,11 @@ async def try_until(
         await asyncio.sleep(time_between_attempts)
     else:
         raise TimeoutError(f"No success in {timeout} seconds.")
+
+
+def has_messages(response: MessagesResponse) -> bool:
+    return len(response.messages) > 0
+
+
+def has_no_messages(response: MessagesResponse) -> bool:
+    return len(response.messages) == 0

tests/unit/test_asynchronous_get.py

@@ -23,6 +23,9 @@ async def __aexit__(self, exc_type, exc_val, exc_tb):
         def status(self):
             return 200
 
+        def raise_for_status(self):
+            ...
+
         async def json(self):
             return get_return_value