Online test for message send-receive

Author: link2xt

deltachat-rpc-client/src/deltachat_rpc_client/__init__.py

@@ -1,7 +1,8 @@
 from .account import Account
+from .contact import Contact
 from .deltachat import Deltachat
+from .message import Message
 from .rpc import Rpc, new_online_account, start_rpc_server
-from .contact import Contact
 
 
 async def main():

deltachat-rpc-client/src/deltachat_rpc_client/account.py

@@ -1,31 +1,43 @@
 from typing import Optional
 
+from .contact import Contact
+
 
 class Account:
-    def __init__(self, rpc, id):
-        self.id = id
+    def __init__(self, rpc, account_id):
         self.rpc = rpc
+        self.account_id = account_id
 
     async def remove(self) -> None:
-        await self.rpc.remove_account(self.id)
+        await self.rpc.remove_account(self.account_id)
 
     async def start_io(self) -> None:
-        await self.rpc.start_io(self.id)
+        await self.rpc.start_io(self.account_id)
 
     async def stop_io(self) -> None:
-        await self.rpc.stop_io(self.id)
+        await self.rpc.stop_io(self.account_id)
 
     async def get_info(self):
-        return await self.rpc.get_info(self.id)
+        return await self.rpc.get_info(self.account_id)
 
     async def get_file_size(self):
-        return await self.rpc.get_account_file_size(self.id)
+        return await self.rpc.get_account_file_size(self.account_id)
 
     async def is_configured(self) -> bool:
-        return await self.rpc.is_configured(self.id)
+        return await self.rpc.is_configured(self.account_id)
+
+    async def set_config(self, key: str, value: Optional[str]):
+        await self.rpc.set_config(self.account_id, key, value)
+
+    async def get_config(self, key: str) -> Optional[str]:
+        return await self.rpc.get_config(self.account_id, key)
 
-    async def set_config(key: str, value: Optional[str]):
-        await self.rpc.set_config(self.id, key, value)
+    async def configure(self):
+        await self.rpc.configure(self.account_id)
 
-    async def get_config(key: str) -> Optional[str]:
-        return await self.rpc.get_config(self.id, key)
+    async def create_contact(self, email: str, name: Optional[str]):
+        return Contact(
+            self.rpc,
+            self.account_id,
+            await self.rpc.create_contact(self.account_id, email, name),
+        )

deltachat-rpc-client/src/deltachat_rpc_client/chat.py

@@ -0,0 +1,26 @@
+from .message import Message
+
+
+class Chat:
+    def __init__(self, rpc, account_id, chat_id):
+        self.rpc = rpc
+        self.account_id = account_id
+        self.chat_id = chat_id
+
+    async def block(self):
+        await self.rpc.block_chat(self.account_id, self.chat_id)
+
+    async def accept(self):
+        await self.rpc.accept_chat(self.account_id, self.chat_id)
+
+    async def delete(self):
+        await self.rpc.delete_chat(self.account_id, self.chat_id)
+
+    async def get_encryption_info(self):
+        await self.rpc.get_chat_encryption_info(self.account_id, self.chat_id)
+
+    async def send_text(self, text: str):
+        msg_id = await self.rpc.misc_send_text_message(
+            self.account_id, self.chat_id, text
+        )
+        return Message(self.rpc, self.account_id, msg_id)

deltachat-rpc-client/src/deltachat_rpc_client/contact.py

@@ -1,9 +1,13 @@
+from .chat import Chat
+
+
 class Contact:
     """
     Contact API.
 
     Essentially a wrapper for RPC, account ID and a contact ID.
     """
+
     def __init__(self, rpc, account_id, contact_id):
         self.rpc = rpc
         self.account_id = account_id
@@ -25,8 +29,17 @@ async def change_name(self, name: str):
         await self.rpc.change_contact_name(self.account_id, self.contact_id, name)
 
     async def get_encryption_info(self) -> str:
-        return await self.rpc.get_contact_encryption_info(self.account_id, self.contact_id)
+        return await self.rpc.get_contact_encryption_info(
+            self.account_id, self.contact_id
+        )
 
     async def get_dictionary(self):
         """Returns a dictionary with a snapshot of all contact properties."""
         return await self.rpc.get_contact(self.account_id, self.contact_id)
+
+    async def create_chat(self):
+        return Chat(
+            self.rpc,
+            self.account_id,
+            await self.rpc.create_chat_by_contact_id(self.account_id, self.contact_id),
+        )

deltachat-rpc-client/src/deltachat_rpc_client/rpc.py

@@ -27,10 +27,11 @@ async def reader_loop(self):
             if "id" in response:
                 fut = self.request_events.pop(response["id"])
                 fut.set_result(response)
+            elif response["method"] == "event":
+                # An event notification.
+                await self.event_queue.put(response["params"])
             else:
-                if response["method"] == "event":
-                    # An event notification.
-                    await self.event_queue.put(response["params"]["event"])
+                print(response)
 
     async def get_next_event(self):
         """Returns next event."""

deltachat-rpc-client/tests/test_something.py

@@ -1,3 +1,4 @@
+import asyncio
 import os
 
 import pytest
@@ -45,7 +46,7 @@ async def test_online_account(rpc):
 
     await rpc.configure(account_id)
     while True:
-        event = await rpc.get_next_event()
+        event = (await rpc.get_next_event())["event"]
         if event["type"] == "ConfigureProgress":
             # Progress 0 indicates error.
             assert event["progress"] != 0
@@ -61,7 +62,36 @@ async def test_online_account(rpc):
 @pytest.mark.asyncio
 async def test_object_account(rpc):
     deltachat = Deltachat(rpc)
-    account = await deltachat.add_account()
-    assert not await account.is_configured()
-    info = await account.get_info()
-    print(info)
+
+    async def create_configured_account():
+        account = await deltachat.add_account()
+        assert not await account.is_configured()
+        account_json = await deltachat_rpc_client.new_online_account()
+        await account.set_config("addr", account_json["email"])
+        await account.set_config("mail_pw", account_json["password"])
+        await account.configure()
+        assert await account.is_configured()
+        return account
+
+    alice_task = asyncio.create_task(create_configured_account())
+    bob_task = asyncio.create_task(create_configured_account())
+
+    alice = await alice_task
+    bob = await bob_task
+
+    alice_contact_bob = await alice.create_contact(await bob.get_config("addr"), "Bob")
+    alice_chat_bob = await alice_contact_bob.create_chat()
+    await alice_chat_bob.send_text("Hello!")
+
+    while True:
+        event = await rpc.get_next_event()
+        if event["contextId"] != bob.account_id:
+            continue
+        event = event["event"]
+        if event["type"] == "IncomingMsg":
+            chat_id = event["chatId"]
+            msg_id = event["msgId"]
+            break
+
+    message = await rpc.get_message(bob.account_id, msg_id)
+    assert message["text"] == "Hello!"