Add async client parity coverage

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Copilot-Session: 76f2163a-0773-4889-b627-1bd4e5c7bea0

Author: andystaples

azure-functions-durable/azure/durable_functions/decorators/durable_app.py

@@ -386,11 +386,9 @@ def durable_client_input(self,
         @self._build_function
         def wrap(fb: FunctionBuilder) -> FunctionBuilder:
             def decorator() -> FunctionBuilder:
-                # The durableClient binding converter
-                # (``DurableClientConverter``) constructs the rich
-                # ``DurableFunctionsClient`` from the host-supplied configuration
-                # string during decode, so no per-function client middleware is
-                # needed here.
+                # The converter returns the host configuration string. The
+                # function wrapper below constructs and closes the requested
+                # synchronous or asynchronous rich client per invocation.
                 fb.add_binding(
                     binding=DurableClient(name=client_name,
                                           task_hub=task_hub,
@@ -400,13 +398,10 @@ def decorator() -> FunctionBuilder:
             return decorator()
 
         def attach_client_function(user_fn: Callable[..., Any]) -> FunctionBuilder:
-            # Expose the raw client function for unit testing, mirroring the
-            # ``.orchestrator_function`` and ``.entity_function`` attributes.
-            # Unlike v1 there is no client middleware wrapper (the durableClient
-            # binding converter builds the rich client during decode), so the
-            # user function is registered directly and ``.client_function``
-            # points back at it. Internal callers pass an already-built
-            # ``FunctionBuilder`` (e.g. history export), which is left untouched.
+            # Expose the original client function for unit testing, mirroring
+            # ``.orchestrator_function`` and ``.entity_function``. The registered
+            # wrapper resolves the client from the binding configuration and
+            # closes it after the invocation.
             from ..client import DurableFunctionsClient, SyncDurableFunctionsClient
 
             function = (user_fn._function._func  # pyright: ignore[reportPrivateUsage]

azure-functions-durable/azure/durable_functions/internal/converters.py

@@ -224,8 +224,9 @@ def register_durable_converters() -> None:
     """Register this package's durable binding converters with azure-functions.
 
     Overrides the SDK's built-in converters for the four durable binding types
-    so the host uses the durabletask-based encodings and the durable-client
-    binding is decoded to a :class:`DurableFunctionsClient`.
+    so the host uses the durabletask-based encodings. The durable-client binding
+    is decoded to its host configuration string, which the decorator converts to
+    the requested synchronous or asynchronous rich client per invocation.
     """
     func.register_converter(
         ORCHESTRATION_TRIGGER, OrchestrationTriggerConverter, overwrite=True)

durabletask/scheduled/__init__.py

@@ -6,7 +6,8 @@
 This package provides a recurring schedule feature built on top of durable
 entities and a helper orchestrator. Enable it on a worker via
 :meth:`durabletask.worker.TaskHubGrpcWorker.configure_scheduled_tasks`, then
-manage schedules from the client via :class:`ScheduledTaskClient`.
+manage schedules from a synchronous :class:`ScheduledTaskClient` or
+asynchronous :class:`AsyncScheduledTaskClient`.
 """
 
 from durabletask.scheduled.client import (AsyncScheduleClient,

tests/durabletask/extensions/history_export/test_client.py

@@ -19,6 +19,7 @@
 
 from durabletask import client, task, worker
 from durabletask.extensions.history_export import (
+    AsyncExportHistoryClient,
     ExportDestination,
     ExportFormat,
     ExportFormatKind,
@@ -148,6 +149,32 @@ def test_create_get_and_wait_for_job_end_to_end(
         assert first["kind"] == "metadata"
 
 
+async def test_async_client_create_list_wait_and_delete(
+    writer, seeded_terminal_instances,
+):
+    async with client.AsyncTaskHubGrpcClient(host_address=HOST) as dt_client:
+        export_client = AsyncExportHistoryClient(dt_client, writer)
+        now = datetime.now(timezone.utc)
+        desc = await export_client.create_job(ExportJobCreationOptions(
+            mode=ExportMode.BATCH,
+            completed_time_from=now - timedelta(hours=1),
+            completed_time_to=now + timedelta(hours=1),
+            destination=ExportDestination(container="exports", prefix="async"),
+            format=ExportFormat(kind=ExportFormatKind.JSON),
+        ))
+
+        final = await export_client.wait_for_job(
+            desc.job_id, timeout=30, poll_interval=0.1)
+        assert final.status == ExportJobStatus.COMPLETED
+        assert (await export_client.get_job(desc.job_id)) is not None
+        assert desc.job_id in {
+            job.job_id async for job in export_client.list_jobs()
+        }
+
+        await export_client.delete_job(desc.job_id)
+        assert await export_client.get_job(desc.job_id) is None
+
+
 def test_get_job_returns_none_for_unknown_id(export_client):
     assert export_client.get_job("does-not-exist") is None
 

tests/durabletask/scheduled/test_scheduled_e2e.py

@@ -10,9 +10,10 @@
 import pytest
 
 from durabletask import client, task, worker
-from durabletask.scheduled import (ScheduledTaskClient, ScheduleCreationOptions,
-                                   ScheduleQuery, ScheduleStatus,
-                                   ScheduleUpdateOptions)
+from durabletask.scheduled import (AsyncScheduledTaskClient,
+                                   ScheduledTaskClient,
+                                   ScheduleCreationOptions, ScheduleQuery,
+                                   ScheduleStatus, ScheduleUpdateOptions)
 from durabletask.testing import create_test_backend
 
 from tests.durabletask._port_utils import find_free_port
@@ -113,6 +114,31 @@ def test_get_nonexistent_returns_none():
             assert scheduled.get_schedule("does-not-exist") is None
 
 
+async def test_async_client_create_list_and_delete():
+    with _make_worker() as w:
+        w.start()
+        async with client.AsyncTaskHubGrpcClient(host_address=HOST) as c:
+            scheduled = AsyncScheduledTaskClient(c)
+            schedule = await scheduled.create_schedule(ScheduleCreationOptions(
+                schedule_id="async-schedule",
+                orchestration_name=task.get_name(target_orchestrator),
+                interval=timedelta(seconds=30),
+                start_at=datetime.now(timezone.utc) + timedelta(hours=1),
+            ))
+
+            assert (await scheduled.get_schedule("async-schedule")) is not None
+            listed = await scheduled.list_schedules(
+                ScheduleQuery(schedule_id_prefix="async-"))
+            assert [item.schedule_id for item in listed] == ["async-schedule"]
+
+            await schedule.pause()
+            assert (await schedule.describe()).status == ScheduleStatus.PAUSED
+            await schedule.resume()
+            assert (await schedule.describe()).status == ScheduleStatus.ACTIVE
+            await schedule.delete()
+            assert await scheduled.get_schedule("async-schedule") is None
+
+
 def test_pause_and_resume():
     with _make_worker() as w:
         w.start()