test: update tests for async-only API

- Convert test conftest to async (fixtures, setup/teardown)
- Remove 174 sync test functions (duplicates of async tests)
- Convert unique sync-only tests to async
- Skip CalDAV tests (not available in async-only mode)
- Convert test entry scripts (_install.py, _talk_bot.py, etc.)
- Update README to reflect async-only API

Author: Review

README.md

@@ -17,21 +17,11 @@ Python library that provides a robust and well-documented API that allows develo
  * **Reliable**: Minimum number of incompatible changes.
  * **Robust**: All code is covered with tests as much as possible.
  * **Easy**: Designed to be easy to use.
- * **Async-first**: Full async API with sync wrappers available for most modules.
-
-### Deprecation notice: sync API
-
-Starting with version **0.30.0**, we are gradually removing sync wrappers in favour of
-the async API. The following modules have already lost their sync counterparts:
-**Activity**, **Notes**, **User Status**, and **Weather Status**.
-
-All remaining sync methods will be phased out in future releases. If you are still
-using the sync `Nextcloud` / `NextcloudApp` classes, we recommend migrating to
-`AsyncNextcloud` / `AsyncNextcloudApp` as soon as possible.
+ * **Async**: Fully async API built on top of `niquests`.
 
 ### Differences between the Nextcloud and NextcloudApp classes
 
-The **Nextcloud** class functions as a standard Nextcloud client,
+The **Nextcloud** class functions as a standard async Nextcloud client,
 enabling you to make API requests using a username and password.
 
 On the other hand, the **NextcloudApp** class is designed for creating applications for Nextcloud.<br>
@@ -52,7 +42,7 @@ from contextlib import asynccontextmanager
 
 from fastapi import FastAPI
 
-from nc_py_api import AsyncNextcloudApp
+from nc_py_api import NextcloudApp
 from nc_py_api.ex_app import AppAPIAuthMiddleware, LogLvl, run_app, set_handlers
 
 
@@ -66,7 +56,7 @@ APP = FastAPI(lifespan=lifespan)
 APP.add_middleware(AppAPIAuthMiddleware)
 
 
-async def enabled_handler(enabled: bool, nc: AsyncNextcloudApp) -> str:
+async def enabled_handler(enabled: bool, nc: NextcloudApp) -> str:
     if enabled:
         await nc.log(LogLvl.WARNING, "Hello from nc_py_api.")
     else:

tests/_install.py

@@ -17,33 +17,33 @@ async def lifespan(_app: FastAPI):
 
 
 @APP.put("/sec_check")
-def sec_check(
+async def sec_check(
     value: int,
     _nc: typing.Annotated[NextcloudApp, Depends(ex_app.nc_app)],
 ):
     print(value, flush=True)
     return JSONResponse(content={"error": ""}, status_code=200)
 
 
-def init_handler_background(nc: NextcloudApp):
-    nc.set_init_status(100)
+async def init_handler_background(nc: NextcloudApp):
+    await nc.set_init_status(100)
 
 
 @APP.post("/init")
-def init_handler(
+async def init_handler(
     background_tasks: BackgroundTasks,
     nc: typing.Annotated[NextcloudApp, Depends(ex_app.nc_app)],
 ):
     background_tasks.add_task(init_handler_background, nc)
     return JSONResponse(content={}, status_code=200)
 
 
-def enabled_handler(enabled: bool, nc: NextcloudApp) -> str:
+async def enabled_handler(enabled: bool, nc: NextcloudApp) -> str:
     print(f"enabled_handler: enabled={enabled}", flush=True)
     if enabled:
-        nc.log(ex_app.LogLvl.WARNING, f"Hello from {nc.app_cfg.app_name} :)")
+        await nc.log(ex_app.LogLvl.WARNING, f"Hello from {nc.app_cfg.app_name} :)")
     else:
-        nc.log(ex_app.LogLvl.WARNING, f"Bye bye from {nc.app_cfg.app_name} :(")
+        await nc.log(ex_app.LogLvl.WARNING, f"Bye bye from {nc.app_cfg.app_name} :(")
     return ""
 
 

tests/_install_init_handler_models.py

@@ -28,7 +28,7 @@ async def lifespan(_app: FastAPI):
 APP = FastAPI(lifespan=lifespan)
 
 
-def enabled_handler(enabled: bool, _nc: NextcloudApp) -> str:
+async def enabled_handler(enabled: bool, _nc: NextcloudApp) -> str:
     if enabled:
         assert ex_app.get_model_path(MODEL_NAME2)
         assert Path("pytorch_model.bin").is_file()

tests/_install_only_enabled_handler.py

@@ -14,7 +14,7 @@ async def lifespan(_app: FastAPI):
 APP = FastAPI(lifespan=lifespan)
 
 
-def enabled_handler(_enabled: bool, _nc: NextcloudApp) -> str:
+async def enabled_handler(_enabled: bool, _nc: NextcloudApp) -> str:
     return ""
 
 

tests/_talk_bot.py

@@ -13,13 +13,13 @@
 COVERAGE_BOT = talk_bot.TalkBot("/talk_bot_coverage", "Coverage bot", "Desc")
 
 
-def coverage_talk_bot_process_request(message: talk_bot.TalkBotMessage, request: Request):
+async def coverage_talk_bot_process_request(message: talk_bot.TalkBotMessage, request: Request):
     if message.object_name != "message":
         return
-    COVERAGE_BOT.react_to_message(message, "🥳")
-    COVERAGE_BOT.react_to_message(message, "🫡")
-    COVERAGE_BOT.delete_reaction(message, "🫡")
-    COVERAGE_BOT.send_message("Hello from bot!", message)
+    await COVERAGE_BOT.react_to_message(message, "🥳")
+    await COVERAGE_BOT.react_to_message(message, "🫡")
+    await COVERAGE_BOT.delete_reaction(message, "🫡")
+    await COVERAGE_BOT.send_message("Hello from bot!", message)
     assert isinstance(message.actor_id, str)
     assert isinstance(message.actor_display_name, str)
     assert isinstance(message.object_name, str)
@@ -28,15 +28,15 @@ def coverage_talk_bot_process_request(message: talk_bot.TalkBotMessage, request:
     assert isinstance(message.conversation_name, str)
     assert str(message).find("conversation=") != -1
     with pytest.raises(ValueError):
-        COVERAGE_BOT.react_to_message(message.object_id, "🥳")
+        await COVERAGE_BOT.react_to_message(message.object_id, "🥳")
     with pytest.raises(ValueError):
-        COVERAGE_BOT.delete_reaction(message.object_id, "🥳")
+        await COVERAGE_BOT.delete_reaction(message.object_id, "🥳")
     with pytest.raises(ValueError):
-        COVERAGE_BOT.send_message("🥳", message.object_id)
+        await COVERAGE_BOT.send_message("🥳", message.object_id)
 
 
 @APP.post("/talk_bot_coverage")
-def talk_bot_coverage(
+async def talk_bot_coverage(
     request: Request,
     _nc: Annotated[NextcloudApp, Depends(nc_app)],
     message: Annotated[talk_bot.TalkBotMessage, Depends(talk_bot_msg)],
@@ -48,7 +48,7 @@ def talk_bot_coverage(
 
 # in real program this is not needed, as bot enabling handler is called in the bots process itself and will reset it.
 @APP.delete("/reset_bot_secret")
-def reset_bot_secret():
+async def reset_bot_secret():
     os.environ.pop(talk_bot.__get_bot_secret("/talk_bot_coverage"), None)
     return Response()
 

tests/_tests_at_the_end.py

@@ -22,24 +22,23 @@ def _test_ex_app_enable_disable(file_to_test):
 
 
 @pytest.mark.parametrize("file_to_test", ("_install_only_enabled_handler.py", "_install_only_enabled_handler_async.py"))
-def test_ex_app_enable_disable(nc_client, nc_app, file_to_test):
+async def test_ex_app_enable_disable(nc_client, nc_app, file_to_test):
     r, url = _test_ex_app_enable_disable(file_to_test)
     try:
         if check_heartbeat(url, '"status":"ok"', 15, 0.3):
             raise RuntimeError(f"`{file_to_test}` can not start.")
-        if nc_client.apps.ex_app_is_enabled("nc_py_api"):
-            nc_client.apps.ex_app_disable("nc_py_api")
-        assert nc_client.apps.ex_app_is_disabled("nc_py_api") is True
-        assert nc_client.apps.ex_app_is_enabled("nc_py_api") is False
-        nc_client.apps.ex_app_enable("nc_py_api")
-        assert nc_client.apps.ex_app_is_disabled("nc_py_api") is False
-        assert nc_client.apps.ex_app_is_enabled("nc_py_api") is True
+        if await nc_client.apps.ex_app_is_enabled("nc_py_api"):
+            await nc_client.apps.ex_app_disable("nc_py_api")
+        assert await nc_client.apps.ex_app_is_disabled("nc_py_api") is True
+        assert await nc_client.apps.ex_app_is_enabled("nc_py_api") is False
+        await nc_client.apps.ex_app_enable("nc_py_api")
+        assert await nc_client.apps.ex_app_is_disabled("nc_py_api") is False
+        assert await nc_client.apps.ex_app_is_enabled("nc_py_api") is True
     finally:
         r.terminate()
         r.wait(timeout=10)
 
 
-@pytest.mark.asyncio(scope="session")
 @pytest.mark.parametrize("file_to_test", ("_install_only_enabled_handler.py", "_install_only_enabled_handler_async.py"))
 async def test_ex_app_enable_disable_async(anc_client, anc_app, file_to_test):
     r, url = _test_ex_app_enable_disable(file_to_test)