fix(ex_app): keep set_init_status mockable from sync tests

The previous fix piped every progress update through
``asyncio.run_coroutine_threadsafe(nc.set_init_status(...), loop)``. That works at
runtime but breaks ``tests_unit/test_fetch_model_file.py``, which drives
``fetch_models_task`` from a regular sync test with a ``MagicMock`` ``nc``: there is
no event loop and no real coroutine, so the loop-scheduling branch short-circuits
and ``nc.set_init_status`` was never called at all.

Make ``_ProgressReporter.__call__`` invoke ``nc.set_init_status`` unconditionally so
mocks (and any future sync ``NextcloudApp`` shim) observe the call. Inspect the
return value: if it is a coroutine, schedule it on the captured loop and wait
for the result; if there is no loop available, ``coro.close()`` to avoid the
"coroutine never awaited" warning; if it is not a coroutine at all (the mock
case) just drop it.

Also drop the empty ``error`` argument when calling ``set_init_status`` to keep
the call signature identical to the pre-Phase-2 behaviour, so existing tests
that assert ``call(100)`` rather than ``call(100, "")`` keep matching.

Author: Review

nc_py_api/ex_app/integration_fastapi.py

@@ -200,19 +200,29 @@ class _ProgressReporter:
     """Bridges sync model-fetch code to the async :py:meth:`NextcloudApp.set_init_status`.
 
     ``fetch_models_task`` runs in a FastAPI ``BackgroundTasks`` worker thread when the caller
-    is sync, so we cannot ``await`` here. Each call schedules a coroutine on the captured main
-    event loop and waits for the result to keep progress reporting linearizable; if no loop
-    is available the call is silently dropped so model downloads still proceed.
+    is sync, so we cannot ``await`` here. The reporter always calls ``nc.set_init_status`` so
+    that mocks and sync test doubles observe the invocation, then schedules the resulting
+    coroutine on the captured main event loop and waits for the result to keep progress
+    reporting linearizable. If no loop is available the coroutine is closed to avoid a
+    ``coroutine '...' was never awaited`` warning, and the download proceeds anyway.
     """
 
     def __init__(self, nc: NextcloudApp, loop: asyncio.AbstractEventLoop | None):
         self._nc = nc
         self._loop = loop
 
     def __call__(self, progress: int, error: str = "") -> None:
+        # Call ``set_init_status`` with the same signature the bare sync API used (omitting
+        # ``error`` when empty) so existing mocks keep matching ``call(100)`` rather than
+        # ``call(100, "")``.
+        result = self._nc.set_init_status(progress) if not error else self._nc.set_init_status(progress, error)
+        if not asyncio.iscoroutine(result):
+            # Mocked or sync wrapper - the call has been observed, nothing else to do.
+            return
         if self._loop is None or self._loop.is_closed():
+            result.close()
             return
-        future = asyncio.run_coroutine_threadsafe(self._nc.set_init_status(progress, error), self._loop)
+        future = asyncio.run_coroutine_threadsafe(result, self._loop)
         try:
             future.result(timeout=30)
         except Exception:  # noqa pylint: disable=broad-exception-caught