Mint: table locks (#566)

* clean up db

* db: table lock

* db.table_with_schema

* fix encrypt.py

* postgres nowait

* add timeout to lock

* melt quote state in db

* kinda working

* kinda working with postgres

* remove dispose

* getting there

* porperly clean up db for tests

* faster tests

* configure connection pooling

* try github with connection pool

* invoice dispatcher does not lock db

* fakewallet: pay_if_regtest waits

* pay fakewallet invoices

* add more

* faster

* slower

* pay_if_regtest async

* do not lock the invoice dispatcher

* test: do I get disk I/O errors if we disable the invoice_callback_dispatcher?

* fix fake so it workss without a callback dispatchert

* test on github

* readd tasks

* refactor

* increase time for lock invoice disatcher

* try avoiding a race

* remove task

* github actions: test regtest with postgres

* mint per module

* no connection pool for testing

* enable pool

* do not resend paid event

* reuse connection

* close db connections

* sessions

* enable debug

* dispose engine

* disable connection pool for tests

* enable connection pool for postgres only

* clean up shutdown routine

* remove wait for lightning fakewallet lightning invoice

* cancel invoice listener tasks on shutdown

* fakewallet conftest: decrease outgoing delay

* delay payment and set postgres only if needed

* disable fail fast for regtest

* clean up regtest.yml

* change order of tests_db.py

* row-specific mint_quote locking

* refactor

* fix lock statement

* refactor swap

* refactor

* remove psycopg2

* add connection string example to .env.example

* remove unnecessary pay

* shorter sleep in test_wallet_subscription_swap

tests/helpers.py

@@ -1,3 +1,4 @@
+import asyncio
 import hashlib
 import importlib
 import json
@@ -6,13 +7,44 @@ import random
 import string
 import time
 from subprocess import PIPE, Popen, TimeoutExpired
-from typing import Tuple
+from typing import List, Tuple, Union
 
 from loguru import logger
 
+from cashu.core.errors import CashuError
 from cashu.core.settings import settings
 
 
+async def assert_err(f, msg: Union[str, CashuError]):
+    """Compute f() and expect an error message 'msg'."""
+    try:
+        await f
+    except Exception as exc:
+        error_message: str = str(exc.args[0])
+        if isinstance(msg, CashuError):
+            if msg.detail not in error_message:
+                raise Exception(
+                    f"CashuError. Expected error: {msg.detail}, got: {error_message}"
+                )
+            return
+        if msg not in error_message:
+            raise Exception(f"Expected error: {msg}, got: {error_message}")
+        return
+    raise Exception(f"Expected error: {msg}, got no error")
+
+
+async def assert_err_multiple(f, msgs: List[str]):
+    """Compute f() and expect an error message 'msg'."""
+    try:
+        await f
+    except Exception as exc:
+        for msg in msgs:
+            if msg in str(exc.args[0]):
+                return
+        raise Exception(f"Expected error: {msgs}, got: {exc.args[0]}")
+    raise Exception(f"Expected error: {msgs}, got no error")
+
+
 def get_random_string(N: int = 10):
     return "".join(
         random.SystemRandom().choice(string.ascii_uppercase + string.digits)
@@ -157,6 +189,9 @@ def pay_onchain(address: str, sats: int) -> str:
     return run_cmd(cmd)
 
 
-def pay_if_regtest(bolt11: str):
+async def pay_if_regtest(bolt11: str):
     if is_regtest:
         pay_real_invoice(bolt11)
+    if is_fake:
+        await asyncio.sleep(settings.fakewallet_delay_incoming_payment or 0)
+    await asyncio.sleep(0.1)