Drop @callback and other unused async helpers (#75)

* Bye bye `@callback`

* Fix unit tests

* Drop `async_run_job`

* Drop `run_callback_threadsafe`

Author: puddly

tests/test_async_.py

@@ -3,45 +3,28 @@
 import asyncio
 import functools
 import time
-from unittest.mock import MagicMock, Mock, patch
+from unittest.mock import MagicMock, patch
 
 import pytest
 
 from zha import async_ as zha_async
 from zha.application.gateway import Gateway
 from zha.async_ import AsyncUtilMixin, ZHAJob, ZHAJobType, create_eager_task
-from zha.decorators import callback
-
-
-async def test_zhajob_forbid_coroutine() -> None:
-    """Test zhajob forbids coroutines."""
-
-    async def bla():
-        pass
-
-    coro = bla()
-
-    with pytest.raises(ValueError):
-        _ = ZHAJob(coro).job_type
-
-    # To avoid warning about unawaited coro
-    await coro
 
 
 @pytest.mark.parametrize("eager_start", [True, False])
 async def test_cancellable_zhajob(zha_gateway: Gateway, eager_start: bool) -> None:
     """Simulate a shutdown, ensure cancellable jobs are cancelled."""
     job = MagicMock()
 
-    @callback
     def run_job(job: ZHAJob) -> None:
         """Call the action."""
         zha_gateway.async_run_zha_job(job, eager_start=eager_start)
 
     timer1 = zha_gateway.loop.call_later(
-        60, run_job, ZHAJob(callback(job), cancel_on_shutdown=True)
+        60, run_job, ZHAJob(job, cancel_on_shutdown=True)
     )
-    timer2 = zha_gateway.loop.call_later(60, run_job, ZHAJob(callback(job)))
+    timer2 = zha_gateway.loop.call_later(60, run_job, ZHAJob(job))
 
     await zha_gateway.shutdown()
 
@@ -57,7 +40,7 @@ async def test_async_add_zha_job_schedule_callback() -> None:
     zha_gateway = MagicMock(loop=MagicMock(wraps=asyncio.get_running_loop()))
     job = MagicMock()
 
-    AsyncUtilMixin.async_add_zha_job(zha_gateway, ZHAJob(callback(job)))
+    AsyncUtilMixin.async_add_zha_job(zha_gateway, ZHAJob(job))
     assert len(zha_gateway.loop.call_soon.mock_calls) == 1
     assert len(zha_gateway.loop.create_task.mock_calls) == 0
     assert len(zha_gateway.add_job.mock_calls) == 0
@@ -71,9 +54,7 @@ async def test_async_add_zha_job_eager_start_coro_suspends(
     async def job_that_suspends():
         await asyncio.sleep(0)
 
-    task = zha_gateway.async_add_zha_job(
-        ZHAJob(callback(job_that_suspends)), eager_start=True
-    )
+    task = zha_gateway.async_add_zha_job(ZHAJob(job_that_suspends), eager_start=True)
     assert not task.done()
     assert task in zha_gateway._tracked_completable_tasks
     await task
@@ -88,7 +69,7 @@ async def test_async_run_zha_job_eager_start_coro_suspends(
     async def job_that_suspends():
         await asyncio.sleep(0)
 
-    task = zha_gateway.async_run_zha_job(ZHAJob(callback(job_that_suspends)))
+    task = zha_gateway.async_run_zha_job(ZHAJob(job_that_suspends))
     assert not task.done()
     assert task in zha_gateway._tracked_completable_tasks
     await task
@@ -101,9 +82,7 @@ async def test_async_add_zha_job_background(zha_gateway: Gateway) -> None:
     async def job_that_suspends():
         await asyncio.sleep(0)
 
-    task = zha_gateway.async_add_zha_job(
-        ZHAJob(callback(job_that_suspends)), background=True
-    )
+    task = zha_gateway.async_add_zha_job(ZHAJob(job_that_suspends), background=True)
     assert not task.done()
     assert task in zha_gateway._background_tasks
     await task
@@ -116,9 +95,7 @@ async def test_async_run_zha_job_background(zha_gateway: Gateway) -> None:
     async def job_that_suspends():
         await asyncio.sleep(0)
 
-    task = zha_gateway.async_run_zha_job(
-        ZHAJob(callback(job_that_suspends)), background=True
-    )
+    task = zha_gateway.async_run_zha_job(ZHAJob(job_that_suspends), background=True)
     assert not task.done()
     assert task in zha_gateway._background_tasks
     await task
@@ -131,9 +108,7 @@ async def test_async_add_zha_job_eager_background(zha_gateway: Gateway) -> None:
     async def job_that_suspends():
         await asyncio.sleep(0)
 
-    task = zha_gateway.async_add_zha_job(
-        ZHAJob(callback(job_that_suspends)), background=True
-    )
+    task = zha_gateway.async_add_zha_job(ZHAJob(job_that_suspends), background=True)
     assert not task.done()
     assert task in zha_gateway._background_tasks
     await task
@@ -146,43 +121,28 @@ async def test_async_run_zha_job_eager_background(zha_gateway: Gateway) -> None:
     async def job_that_suspends():
         await asyncio.sleep(0)
 
-    task = zha_gateway.async_run_zha_job(
-        ZHAJob(callback(job_that_suspends)), background=True
-    )
+    task = zha_gateway.async_run_zha_job(ZHAJob(job_that_suspends), background=True)
     assert not task.done()
     assert task in zha_gateway._background_tasks
     await task
     assert task not in zha_gateway._background_tasks
 
 
-async def test_async_run_zha_job_background_synchronous(
+@pytest.mark.parametrize("background", [True, False])
+async def test_async_run_zha_job_background_no_suspend(
     zha_gateway: Gateway,
+    background: bool,
 ) -> None:
     """Test scheduling a coro as an eager background task with async_run_zha_job."""
 
     async def job_that_does_not_suspends():
         pass
 
     task = zha_gateway.async_run_zha_job(
-        ZHAJob(callback(job_that_does_not_suspends)),
-        background=True,
-    )
-    assert task.done()
-    assert task not in zha_gateway._background_tasks
-    assert task not in zha_gateway._tracked_completable_tasks
-    await task
-
-
-async def test_async_run_zha_job_synchronous(zha_gateway: Gateway) -> None:
-    """Test scheduling a coro as an eager task with async_run_zha_job."""
-
-    async def job_that_does_not_suspends():
-        pass
-
-    task = zha_gateway.async_run_zha_job(
-        ZHAJob(callback(job_that_does_not_suspends)),
-        background=False,
+        ZHAJob(job_that_does_not_suspends),
+        background=background,
     )
+    assert task is not None
     assert task.done()
     assert task not in zha_gateway._background_tasks
     assert task not in zha_gateway._tracked_completable_tasks
@@ -219,7 +179,7 @@ async def test_async_add_zha_job_schedule_partial_callback() -> None:
     """Test that we schedule partial coros and add jobs to the job pool."""
     zha_gateway = MagicMock(loop=MagicMock(wraps=asyncio.get_running_loop()))
     job = MagicMock()
-    partial = functools.partial(callback(job))
+    partial = functools.partial(job)
 
     AsyncUtilMixin.async_add_zha_job(zha_gateway, ZHAJob(partial))
     assert len(zha_gateway.loop.call_soon.mock_calls) == 1
@@ -252,6 +212,7 @@ async def job():
     ) as mock_create_eager_task:
         zha_job = ZHAJob(job)
         task = AsyncUtilMixin.async_add_zha_job(zha_gateway, zha_job, eager_start=True)
+        assert task is not None
         assert len(zha_gateway.loop.call_soon.mock_calls) == 0
         assert len(zha_gateway.add_job.mock_calls) == 0
         assert mock_create_eager_task.mock_calls
@@ -283,9 +244,9 @@ def job():
         pass
 
     AsyncUtilMixin.async_add_zha_job(zha_gateway, ZHAJob(job))
-    assert len(zha_gateway.loop.call_soon.mock_calls) == 0
+    assert len(zha_gateway.loop.call_soon.mock_calls) == 1
     assert len(zha_gateway.loop.create_task.mock_calls) == 0
-    assert len(zha_gateway.loop.run_in_executor.mock_calls) == 2
+    assert len(zha_gateway.loop.run_in_executor.mock_calls) == 0
 
 
 async def test_async_create_task_schedule_coroutine() -> None:
@@ -337,7 +298,7 @@ def job():
         asyncio.get_running_loop()  # ensure we are in the event loop
         calls.append(1)
 
-    AsyncUtilMixin.async_run_zha_job(zha_gateway, ZHAJob(callback(job)))
+    AsyncUtilMixin.async_run_zha_job(zha_gateway, ZHAJob(job))
     assert len(calls) == 1
 
 
@@ -360,24 +321,11 @@ async def test_async_run_zha_job_calls_callback() -> None:
     def job():
         calls.append(1)
 
-    AsyncUtilMixin.async_run_zha_job(zha_gateway, ZHAJob(callback(job)))
+    AsyncUtilMixin.async_run_zha_job(zha_gateway, ZHAJob(job))
     assert len(calls) == 1
     assert len(zha_gateway.async_add_job.mock_calls) == 0
 
 
-async def test_async_run_zha_job_delegates_non_async() -> None:
-    """Test that the callback annotation is respected."""
-    zha_gateway = MagicMock()
-    calls = []
-
-    def job():
-        calls.append(1)
-
-    AsyncUtilMixin.async_run_zha_job(zha_gateway, ZHAJob(job))
-    assert len(calls) == 0
-    assert len(zha_gateway.async_add_zha_job.mock_calls) == 1
-
-
 async def test_async_create_task_pending_tasks_coro(zha_gateway: Gateway) -> None:
     """Add a coro to pending tasks."""
     call_count = []
@@ -395,34 +343,6 @@ async def test_coro():
     assert len(zha_gateway._tracked_completable_tasks) == 0
 
 
-async def test_async_run_job_starts_tasks_eagerly(zha_gateway: Gateway) -> None:
-    """Test async_run_job starts tasks eagerly."""
-    runs = []
-
-    async def _test():
-        runs.append(True)
-
-    task = zha_gateway.async_run_job(_test)
-    # No call to zha_gateway.async_block_till_done to ensure the task is run eagerly
-    assert len(runs) == 1
-    assert task.done()
-    await task
-
-
-async def test_async_run_job_starts_coro_eagerly(zha_gateway: Gateway) -> None:
-    """Test async_run_job starts coros eagerly."""
-    runs = []
-
-    async def _test():
-        runs.append(True)
-
-    task = zha_gateway.async_run_job(_test())
-    # No call to zha_gateway.async_block_till_done to ensure the task is run eagerly
-    assert len(runs) == 1
-    assert task.done()
-    await task
-
-
 @pytest.mark.parametrize("eager_start", [True, False])
 async def test_background_task(zha_gateway: Gateway, eager_start: bool) -> None:
     """Test background tasks being quit."""
@@ -447,7 +367,6 @@ async def test_task():
 def test_ZHAJob_passing_job_type():
     """Test passing the job type to ZHAJob when we already know it."""
 
-    @callback
     def callback_func():
         pass
 
@@ -506,31 +425,6 @@ async def _async_add_executor_job():
     await task
 
 
-@patch("concurrent.futures.Future")
-@patch("threading.get_ident")
-def test_run_callback_threadsafe_from_inside_event_loop(mock_ident, _) -> None:
-    """Testing calling run_callback_threadsafe from inside an event loop."""
-    callback_fn = MagicMock()
-
-    loop = Mock(spec=["call_soon_threadsafe"])
-
-    loop._thread_ident = None
-    mock_ident.return_value = 5
-    zha_async.run_callback_threadsafe(loop, callback_fn)
-    assert len(loop.call_soon_threadsafe.mock_calls) == 1
-
-    loop._thread_ident = 5
-    mock_ident.return_value = 5
-    with pytest.raises(RuntimeError):
-        zha_async.run_callback_threadsafe(loop, callback_fn)
-    assert len(loop.call_soon_threadsafe.mock_calls) == 1
-
-    loop._thread_ident = 1
-    mock_ident.return_value = 5
-    zha_async.run_callback_threadsafe(loop, callback_fn)
-    assert len(loop.call_soon_threadsafe.mock_calls) == 2
-
-
 async def test_gather_with_limited_concurrency() -> None:
     """Test gather_with_limited_concurrency limits the number of running tasks."""
 
@@ -553,74 +447,6 @@ async def _increment_runs_if_in_time():
     assert results == [2, 2, -1, -1]
 
 
-async def test_shutdown_run_callback_threadsafe(zha_gateway: Gateway) -> None:
-    """Test we can shutdown run_callback_threadsafe."""
-    zha_async.shutdown_run_callback_threadsafe(zha_gateway.loop)
-    callback_fn = MagicMock()
-
-    with pytest.raises(RuntimeError):
-        zha_async.run_callback_threadsafe(zha_gateway.loop, callback_fn)
-
-
-async def test_run_callback_threadsafe(zha_gateway: Gateway) -> None:
-    """Test run_callback_threadsafe runs code in the event loop."""
-    it_ran = False
-
-    def callback_fn():
-        nonlocal it_ran
-        it_ran = True
-
-    assert zha_async.run_callback_threadsafe(zha_gateway.loop, callback_fn)
-    assert it_ran is False
-
-    # Verify that async_block_till_done will flush
-    # out the callback
-    await zha_gateway.async_block_till_done()
-    assert it_ran is True
-
-
-async def test_run_callback_threadsafe_exception(zha_gateway: Gateway) -> None:
-    """Test run_callback_threadsafe runs code in the event loop."""
-    it_ran = False
-
-    def callback_fn():
-        nonlocal it_ran
-        it_ran = True
-        raise ValueError("Test")
-
-    future = zha_async.run_callback_threadsafe(zha_gateway.loop, callback_fn)
-    assert future
-    assert it_ran is False
-
-    # Verify that async_block_till_done will flush
-    # out the callback
-    await zha_gateway.async_block_till_done()
-    assert it_ran is True
-
-    with pytest.raises(ValueError):
-        future.result()
-
-
-async def test_callback_is_always_scheduled(zha_gateway: Gateway) -> None:
-    """Test run_callback_threadsafe always calls call_soon_threadsafe before checking for shutdown."""
-    # We have to check the shutdown state AFTER the callback is scheduled otherwise
-    # the function could continue on and the caller call `future.result()` after
-    # the point in the main thread where callbacks are no longer run.
-
-    callback_fn = MagicMock()
-    zha_async.shutdown_run_callback_threadsafe(zha_gateway.loop)
-
-    with (
-        patch.object(
-            zha_gateway.loop, "call_soon_threadsafe"
-        ) as mock_call_soon_threadsafe,
-        pytest.raises(RuntimeError),
-    ):
-        zha_async.run_callback_threadsafe(zha_gateway.loop, callback_fn)
-
-    mock_call_soon_threadsafe.assert_called_once()
-
-
 async def test_create_eager_task_312(zha_gateway: Gateway) -> None:  # pylint: disable=unused-argument
     """Test create_eager_task schedules a task eagerly in the event loop.