def test_loop_run_until_complete_when_set_is_running(loop: GLibEventLoop):
loop.set_is_running(True)
future = asyncio.Future(loop=loop)
with raises(RuntimeError):
loop.run_until_complete(future)
def test_loop_run_until_complete_when_already_running(loop: GLibEventLoop):
async def main():
future = asyncio.Future(loop=loop)
loop.run_until_complete(future)
with raises(RuntimeError):
loop.run_until_complete(main())
def test_loop_run_until_complete_early_stop(loop: GLibEventLoop):
future = asyncio.Future(loop=loop)
idle_add(loop.context, loop.stop)
with raises(RuntimeError):
loop.run_until_complete(future)
def test_loop_run_until_complete_when_not_owner(loop: GLibEventLoop):
from aioglib._loop import GLibEventLoop
context = MockMainContext(is_owner=False)
loop = GLibEventLoop(context)
with raises(RuntimeError):
future = asyncio.Future(loop=loop)
loop.run_until_complete(future)
def test_loop_run_until_complete_exception(loop: GLibEventLoop):
future = asyncio.Future(loop=loop)
class MyException(Exception):
pass
idle_add(loop.context,
lambda: future.set_exception(MyException('my message')))
with raises(MyException, match='my message'):
loop.run_until_complete(future)
def test_loop_run_until_complete_releases_context():
from gi.repository.GLib import MainLoop as MockMainLoop
from aioglib._loop import GLibEventLoop
mock_context = MockMainContext()
loop = GLibEventLoop(mock_context)
future = asyncio.Future(loop=loop)
MockMainLoop().run.side_effect = lambda: future.set_result(None)
MockMainLoop().is_running.return_value = False
loop.run_until_complete(future)
assert mock_context.acquire_count == 0
def test_loop_run_until_complete_with_coro(loop: GLibEventLoop):
async def coro():
return 'something'
result = loop.run_until_complete(coro())
assert result == 'something'
def test_loop_run_until_complete(loop: GLibEventLoop):
future = asyncio.Future(loop=loop)
running_loop_check = True
always_running_check = True
num = 10
def countdown():
nonlocal num, running_loop_check, always_running_check
num -= 1
if asyncio.get_running_loop() is not loop:
running_loop_check = False
always_running_check = loop.is_running() and always_running_check
if num == 0:
future.set_result('something')
return True
context = loop.context
source = idle_add(context, countdown)
result = loop.run_until_complete(future)
assert running_loop_check
assert always_running_check
assert result == 'something'
assert not source.is_destroyed()
def test_loop_create_task(loop: GLibEventLoop):
async def main():
return 123
task = loop.create_task(main())
result = loop.run_until_complete(task)
assert result == 123
def test_loop_run_until_complete_with_awaitable(loop: GLibEventLoop):
class MyAwaitable:
def __await__(self):
return self
def __iter__(self):
return self
def __next__(self):
raise StopIteration('something')
result = loop.run_until_complete(MyAwaitable())
assert result == 'something'
def test_loop_set_is_not_running_when_started_with_run(loop: GLibEventLoop):
async def main():
loop.set_is_running(False)
with raises(RuntimeError):
loop.run_until_complete(main())
def test_loop_set_is_running_when_already_running(loop: GLibEventLoop):
async def main():
loop.set_is_running(True)
with raises(RuntimeError):
loop.run_until_complete(main())
def test_loop_run_forever_when_already_running(loop: GLibEventLoop):
async def main():
loop.run_forever()
with raises(RuntimeError):
loop.run_until_complete(main())
def test_loop_run_until_complete_with_future_on_another_loop(
loop: GLibEventLoop):
future = asyncio.Future(loop=Mock())
with raises(ValueError):
loop.run_until_complete(future)
