Fix asyncio compat tests for Python 3.12+

- Set running loop early in run_until_complete() so task factories
  work correctly before run_forever() is called
- Remove deprecated loop= parameter from asyncio.ensure_future()
- Update test_task_factory to use modern asyncio.Task API with
  eager_start=False parameter

Author: benoitc

priv/_erlang_impl/_loop.py

@@ -220,30 +220,36 @@ def run_until_complete(self, future):
         self._check_closed()
         self._check_running()
 
-        new_task = not futures.isfuture(future)
-        future = tasks.ensure_future(future, loop=self)
+        # Set running loop early so task factories work correctly
+        old_running_loop = events._get_running_loop()
+        events._set_running_loop(self)
+        try:
+            new_task = not futures.isfuture(future)
+            future = tasks.ensure_future(future, loop=self)
 
-        if new_task:
-            future._log_destroy_pending = False
+            if new_task:
+                future._log_destroy_pending = False
 
-        def _done_callback(f):
-            self.stop()
+            def _done_callback(f):
+                self.stop()
 
-        future.add_done_callback(_done_callback)
+            future.add_done_callback(_done_callback)
 
-        try:
-            self.run_forever()
-        except Exception:
-            if new_task and future.done() and not future.cancelled():
-                future.exception()
-            raise
-        finally:
-            future.remove_done_callback(_done_callback)
+            try:
+                self.run_forever()
+            except Exception:
+                if new_task and future.done() and not future.cancelled():
+                    future.exception()
+                raise
+            finally:
+                future.remove_done_callback(_done_callback)
 
-        if not future.done():
-            raise RuntimeError('Event loop stopped before Future completed.')
+            if not future.done():
+                raise RuntimeError('Event loop stopped before Future completed.')
 
-        return future.result()
+            return future.result()
+        finally:
+            events._set_running_loop(old_running_loop)
 
     def stop(self):
         """Stop the event loop."""

priv/tests/test_base.py

@@ -474,18 +474,26 @@ def test_task_factory(self):
         factory_calls = []
 
         def task_factory(loop, coro):
-            factory_calls.append(coro)
-            return asyncio.Task(coro, loop=loop)
+            factory_calls.append(True)
+            # Create task using modern API (Python 3.12+)
+            return asyncio.Task(coro, eager_start=False)
 
         self.loop.set_task_factory(task_factory)
         self.assertEqual(self.loop.get_task_factory(), task_factory)
 
-        async def coro():
+        async def inner():
             return 1
 
-        self.loop.run_until_complete(coro())
+        async def main():
+            # Create task from within running loop
+            task = self.loop.create_task(inner())
+            return await task
+
+        result = self.loop.run_until_complete(main())
+        self.assertEqual(result, 1)
 
-        self.assertEqual(len(factory_calls), 1)
+        # Factory should be called for inner task
+        self.assertGreaterEqual(len(factory_calls), 1)
 
         # Reset
         self.loop.set_task_factory(None)
@@ -723,7 +731,8 @@ async def coro():
             return 42
 
         async def main():
-            future = asyncio.ensure_future(coro(), loop=self.loop)
+            # Note: loop= parameter removed in Python 3.12
+            future = asyncio.ensure_future(coro())
             result = await future
             return result