Disable RUF029 in test files

Author: CoolCat467

pyproject.toml

@@ -152,6 +152,12 @@ extend-ignore = [
 'src/trio/lowlevel.py' = ['F401']
 'src/trio/socket.py' = ['F401']
 'src/trio/testing/__init__.py' = ['F401']
+# RUF029 is ignoring tests that are marked as async functions but
+# do not use an await in their function bodies. There are several
+# places where internal trio synchronous code relies on being
+# called from an async function, where current task is set up.
+'src/trio/_tests/*.py' = ['RUF029']
+'src/trio/_core/_tests/*.py' = ['RUF029']
 
 [tool.ruff.lint.isort]
 combine-as-imports = true

src/trio/_core/_tests/test_asyncgen.py

@@ -189,8 +189,7 @@ def test_last_minute_gc_edge_case() -> None:
     record = []
     needs_retry = True
 
-    # async function missing await
-    async def agen() -> AsyncGenerator[int, None]:  # noqa: RUF029
+    async def agen() -> AsyncGenerator[int, None]:
         try:
             yield 1
         finally:
@@ -271,12 +270,10 @@ def abort_fn(_: _core.RaiseCancelT) -> _core.Abort:
 async def test_fallback_when_no_hook_claims_it(
     capsys: pytest.CaptureFixture[str],
 ) -> None:
-    # async function missing await
-    async def well_behaved() -> AsyncGenerator[int, None]:  # noqa: RUF029
+    async def well_behaved() -> AsyncGenerator[int, None]:
         yield 42
 
-    # async function missing await
-    async def yields_after_yield() -> AsyncGenerator[int, None]:  # noqa: RUF029
+    async def yields_after_yield() -> AsyncGenerator[int, None]:
         with pytest.raises(GeneratorExit):
             yield 42
         yield 100

src/trio/_core/_tests/test_guest_mode.py

@@ -118,7 +118,7 @@ async def trio_return(in_host: InHost) -> str:
 
     assert trivial_guest_run(trio_return) == "ok"
 
-    async def trio_fail(  # noqa: RUF029  # async function missing await
+    async def trio_fail(
         in_host: InHost,
     ) -> NoReturn:
         raise KeyError("whoopsiedaisy")
@@ -256,7 +256,7 @@ async def synchronize() -> None:
 def test_warn_set_wakeup_fd_overwrite() -> None:
     assert signal.set_wakeup_fd(-1) == -1
 
-    async def trio_main(  # noqa: RUF029  # async function missing await
+    async def trio_main(
         in_host: InHost,
     ) -> str:
         return "ok"
@@ -299,8 +299,8 @@ async def trio_main(  # noqa: RUF029  # async function missing await
         # then it's left alone and there's no warning
         signal.set_wakeup_fd(a.fileno())
         try:
-            # async function missing await
-            async def trio_check_wakeup_fd_unaltered(  # noqa: RUF029
+
+            async def trio_check_wakeup_fd_unaltered(
                 in_host: InHost,
             ) -> str:
                 fd = signal.set_wakeup_fd(-1)
@@ -600,8 +600,7 @@ async def trio_main(in_host: InHost) -> None:
     # Also check chaining in the case where KI is injected after main exits
     final_exc = KeyError("whoa")
 
-    # async function missing await
-    async def trio_main_raising(in_host: InHost) -> NoReturn:  # noqa: RUF029
+    async def trio_main_raising(in_host: InHost) -> NoReturn:
         in_host(partial(signal_raise, signal.SIGINT))
         raise final_exc
 

src/trio/_core/_tests/test_instrumentation.py

@@ -168,7 +168,7 @@ def task_spawned(self, task: Task) -> None:
         def task_exited(self, task: Task) -> None:
             record.append(("exited", task))
 
-    async def main() -> Task:  # noqa: RUF029  # async function missing await
+    async def main() -> Task:
         return _core.current_task()
 
     main_task = _core.run(main, instruments=[SpawnExitRecorder()])
@@ -191,7 +191,7 @@ def close(self) -> None:
             # works right.
             record.append("closed")  # pragma: no cover
 
-    async def main() -> Task:  # noqa: RUF029  # async function missing await
+    async def main() -> Task:
         record.append("main ran")
         return _core.current_task()
 
@@ -254,7 +254,7 @@ def task_exited(self, task: Task) -> NoReturn:
         def after_run(self) -> NoReturn:
             raise ValueError("oops")
 
-    async def main() -> None:  # noqa: RUF029  # async function missing await
+    async def main() -> None:
         with pytest.raises(ValueError, match="^oops$"):
             _core.add_instrument(EvilInstrument())
 

src/trio/_core/_tests/test_io.py

@@ -301,8 +301,7 @@ async def receiver(sock: stdlib_socket.socket, key: str) -> None:
     assert results["send_b"] == results["recv_a"]
 
 
-# async function missing await
-async def test_notify_closing_on_invalid_object() -> None:  # noqa: RUF029
+async def test_notify_closing_on_invalid_object() -> None:
     # It should either be a no-op (generally on Unix, where we don't know
     # which fds are valid), or an OSError (on Windows, where we currently only
     # support sockets, so we have to do some validation to figure out whether

src/trio/_core/_tests/test_ki.py

@@ -67,7 +67,7 @@ async def aprotected() -> None:
         await aunprotected()
 
     @_core.disable_ki_protection
-    async def aunprotected() -> None:  # noqa: RUF029  # async fn missing await
+    async def aunprotected() -> None:
         assert not _core.currently_ki_protected()
 
     await aprotected()
@@ -128,8 +128,7 @@ async def child(expected: bool) -> None:
 
 # This also used to be broken due to
 #   https://bugs.python.org/issue29590
-# async function missing await
-async def test_generator_based_context_manager_throw() -> None:  # noqa: RUF029
+async def test_generator_based_context_manager_throw() -> None:
     @contextlib.contextmanager
     @_core.enable_ki_protection
     def protected_manager() -> Iterator[None]:
@@ -196,18 +195,16 @@ async def agen_unprotected2() -> None:
 
 async def test_native_agen_protection() -> None:
     # Native async generators
-    # async function missing await
     @_core.enable_ki_protection
-    async def agen_protected() -> AsyncIterator[None]:  # noqa: RUF029
+    async def agen_protected() -> AsyncIterator[None]:
         assert _core.currently_ki_protected()
         try:
             yield
         finally:
             assert _core.currently_ki_protected()
 
-    # async function missing await
     @_core.disable_ki_protection
-    async def agen_unprotected() -> AsyncIterator[None]:  # noqa: RUF029
+    async def agen_unprotected() -> AsyncIterator[None]:
         assert not _core.currently_ki_protected()
         try:
             yield
@@ -324,9 +321,7 @@ async def check_protected_kill() -> None:
     # error, then kill)
     print("check 3")
 
-    async def check_kill_during_shutdown() -> (  # noqa: RUF029  # async fn missing await
-        None
-    ):
+    async def check_kill_during_shutdown() -> None:
         token = _core.current_trio_token()
 
         def kill_during_shutdown() -> None:
@@ -431,7 +426,7 @@ def abort(raise_cancel: RaiseCancelT) -> Abort:
     print("check 9")
 
     @_core.enable_ki_protection
-    async def main_6() -> None:  # noqa: RUF029  # async function missing await
+    async def main_6() -> None:
         ki_self()
 
     with pytest.raises(KeyboardInterrupt):
@@ -490,7 +485,7 @@ def test_ki_is_good_neighbor() -> None:
         def my_handler(signum: object, frame: object) -> None:  # pragma: no cover
             pass
 
-        async def main() -> None:  # noqa: RUF029  # async function missing await
+        async def main() -> None:
             signal.signal(signal.SIGINT, my_handler)
 
         _core.run(main)
@@ -514,7 +509,7 @@ def test_ki_with_broken_threads() -> None:
         del threading._active[thread.ident]  # type: ignore[attr-defined]
 
         @_core.enable_ki_protection
-        async def inner() -> None:  # noqa: RUF029  # async function missing await
+        async def inner() -> None:
             assert signal.getsignal(signal.SIGINT) != signal.default_int_handler
 
         _core.run(inner)

src/trio/_core/_tests/test_local.py

@@ -13,7 +13,7 @@ def test_runvar_smoketest() -> None:
 
     assert repr(t1) == "<RunVar name='test1'>"
 
-    async def first_check() -> None:  # noqa: RUF029  # async function missing await
+    async def first_check() -> None:
         with pytest.raises(LookupError):
             t1.get()
 
@@ -26,7 +26,7 @@ async def first_check() -> None:  # noqa: RUF029  # async function missing await
         assert t2.get() == "goldfish"
         assert t2.get(default="tuna") == "goldfish"
 
-    async def second_check() -> None:  # noqa: RUF029  # async function missing await
+    async def second_check() -> None:
         with pytest.raises(LookupError):
             t1.get()
 
@@ -41,7 +41,7 @@ def test_runvar_resetting() -> None:
     t2 = RunVar[str]("test2", default="dogfish")
     t3 = RunVar[str]("test3")
 
-    async def reset_check() -> None:  # noqa: RUF029  # async function missing await
+    async def reset_check() -> None:
         token = t1.set("moonfish")
         assert t1.get() == "moonfish"
         t1.reset(token)
@@ -73,12 +73,11 @@ def test_runvar_sync() -> None:
     t1 = RunVar[str]("test1")
 
     async def sync_check() -> None:
-        async def task1() -> None:  # noqa: RUF029  # async fn missing await
+        async def task1() -> None:
             t1.set("plaice")
             assert t1.get() == "plaice"
 
-        # async function missing await
-        async def task2(tok: RunVarToken[str]) -> None:  # noqa: RUF029
+        async def task2(tok: RunVarToken[str]) -> None:
             t1.reset(tok)
 
             with pytest.raises(LookupError):
@@ -110,7 +109,7 @@ def test_accessing_runvar_outside_run_call_fails() -> None:
     with pytest.raises(RuntimeError):
         t1.get()
 
-    async def get_token() -> RunVarToken[str]:  # noqa: RUF029  # async fn missing await
+    async def get_token() -> RunVarToken[str]:
         return t1.set("ok")
 
     token = run(get_token)