better error handling

veilid-python/tests/__init__.py

@@ -1,7 +1,10 @@
+from typing import Callable, Awaitable
+import os
 import pytest
 pytest_plugins = ('pytest_asyncio',)
 
-import os
+import veilid
+
 
 ##################################################################
 VEILID_SERVER = os.getenv("VEILID_SERVER")
@@ -18,5 +21,10 @@ else:
 
 ##################################################################
 
-async def simple_update_callback(update):
+async def simple_connect_and_run(func: Callable[[veilid.VeilidAPI], Awaitable]):
+    api = await veilid.json_api_connect(VEILID_SERVER, VEILID_SERVER_PORT, simple_update_callback)
+    async with api:
+        await func(api)
+
+async def simple_update_callback(update: veilid.VeilidUpdate):
     print("VeilidUpdate: {}".format(update))

veilid-python/tests/test_basic.py

@@ -1,6 +1,6 @@
-# Basic veilid_python tests
+# Basic veilid tests
 
-import veilid_python
+import veilid
 import pytest
 from . import *
 
@@ -8,19 +8,22 @@ from . import *
 
 @pytest.mark.asyncio
 async def test_connect():
-    async with await veilid_python.json_api_connect(VEILID_SERVER, VEILID_SERVER_PORT, simple_update_callback) as api:
+    async def func(api: veilid.VeilidAPI):
         pass
+    await simple_connect_and_run(func)
 
 @pytest.mark.asyncio
 async def test_fail_connect():
     with pytest.raises(Exception):
-        async with await veilid_python.json_api_connect("fuahwelifuh32luhwafluehawea", 1, simple_update_callback) as api:
+        api = await veilid.json_api_connect("fuahwelifuh32luhwafluehawea", 1, simple_update_callback)
+        async with api:
             pass
 
 @pytest.mark.asyncio
 async def test_version():
-    async with await veilid_python.json_api_connect(VEILID_SERVER, VEILID_SERVER_PORT, simple_update_callback) as api:
+    async def func(api: veilid.VeilidAPI):
         v = await api.veilid_version()
         print("veilid_version: {}".format(v.__dict__))
         vstr = await api.veilid_version_string()
         print("veilid_version_string: {}".format(vstr))
+    await simple_connect_and_run(func)

veilid-python/tests/test_crypto.py

@@ -1,6 +1,6 @@
-# Crypto veilid_python tests
+# Crypto veilid tests
 
-import veilid_python
+import veilid
 import pytest
 from . import *
 
@@ -8,21 +8,35 @@ from . import *
 
 @pytest.mark.asyncio
 async def test_best_crypto_system():
-    async with await veilid_python.json_api_connect(VEILID_SERVER, VEILID_SERVER_PORT, simple_update_callback) as api:
+    async def func(api: veilid.VeilidAPI):
         bcs = await api.best_crypto_system()
-        # let handle dangle for test
-        # del bcs
+    await simple_connect_and_run(func)
         
 @pytest.mark.asyncio
 async def test_get_crypto_system():
-    async with await veilid_python.json_api_connect(VEILID_SERVER, VEILID_SERVER_PORT, simple_update_callback) as api:
-        cs = await api.get_crypto_system(veilid_python.CryptoKind.CRYPTO_KIND_VLD0)
+    async def func(api: veilid.VeilidAPI):
+        cs = await api.get_crypto_system(veilid.CryptoKind.CRYPTO_KIND_VLD0)
         # clean up handle early
         del cs
+    await simple_connect_and_run(func)
         
 @pytest.mark.asyncio
 async def test_get_crypto_system_invalid():
-    async with await veilid_python.json_api_connect(VEILID_SERVER, VEILID_SERVER_PORT, simple_update_callback) as api:
-        with pytest.raises(veilid_python.VeilidAPIError):
-            cs = await api.get_crypto_system(veilid_python.CryptoKind.CRYPTO_KIND_NONE)
+    async def func(api: veilid.VeilidAPI):
+        with pytest.raises(veilid.VeilidAPIError):
+            cs = await api.get_crypto_system(veilid.CryptoKind.CRYPTO_KIND_NONE)
+    await simple_connect_and_run(func)
 
+@pytest.mark.asyncio
+async def test_hash_and_verify_password():
+    async def func(api: veilid.VeilidAPI):
+        bcs = await api.best_crypto_system()
+        nonce = await bcs.random_nonce()
+        salt = nonce.to_bytes()
+        # Password match
+        phash = await bcs.hash_password(b"abc123", salt)
+        assert await bcs.verify_password(b"abc123", phash)
+        # Password mismatch
+        phash2 = await bcs.hash_password(b"abc1234", salt)
+        assert not await bcs.verify_password(b"abc12345", phash)
+    await simple_connect_and_run(func)

veilid-python/tests/test_routing_context.py

@@ -0,0 +1,47 @@
+# Routing context veilid tests
+
+import veilid
+import pytest
+import asyncio
+import json
+from . import *
+
+##################################################################
+
+@pytest.mark.asyncio
+async def test_routing_contexts():
+    async def func(api: veilid.VeilidAPI):
+        rc = await api.new_routing_context()
+        rcp = await rc.with_privacy()
+        rcps = await rcp.with_sequencing(veilid.Sequencing.ENSURE_ORDERED)
+        rcpsr = await rcps.with_custom_privacy(veilid.Stability.RELIABLE)
+    await simple_connect_and_run(func)
+
+@pytest.mark.asyncio
+async def test_routing_context_app_message_loopback():
+
+    app_message_queue = asyncio.Queue()
+
+    async def app_message_queue_update_callback(update: veilid.VeilidUpdate):
+        if update.kind == veilid.VeilidUpdateKind.APP_MESSAGE:
+            await app_message_queue.put(update)
+
+    api = await veilid.json_api_connect(VEILID_SERVER, VEILID_SERVER_PORT, app_message_queue_update_callback)
+    async with api:
+    
+        # make a routing context that uses a safety route
+        rc = await (await api.new_routing_context()).with_privacy()
+
+        # get our own node id
+        state = await api.get_state()
+        node_id = state.config.config.network.routing_table.node_id.pop()
+
+        # send an app message to our node id
+        message = b"abcd1234"
+        await rc.app_message(node_id, message)
+
+        # we should get the same message back
+        #update: veilid.VeilidUpdate = await asyncio.wait_for(app_message_queue.get(), timeout=10)
+        #appmsg: veilid.VeilidAppMessage = update.detail
+        #assert appmsg.message == message
+