asyncgui/modified_testcases/test_nursery.py

import unittest
import pytest
from main import open_nursery, TaskState, ExceptionGroup  # Updated import from main.py

class TestAsyncGui(unittest.TestCase):

    def test_one_child(self):
        async def async_fn(ctx):
            async with open_nursery() as nursery:
                ctx['nursery'] = nursery
                ctx['child'] = nursery.start(ag.sleep_forever())

        ctx = {}
        root = ag.start(async_fn(ctx))
        nursery = ctx['nursery']
        child = ctx['child']
        self.assertEqual(root.state, TaskState.STARTED)
        self.assertEqual(child.state, TaskState.STARTED)
        self.assertFalse(nursery.closed)
        child._step()
        self.assertEqual(root.state, TaskState.FINISHED)
        self.assertEqual(child.state, TaskState.FINISHED)
        self.assertTrue(nursery.closed)

    def test_one_daemon(self):
        async def async_fn(ctx):
            async with open_nursery() as nursery:
                ctx['nursery'] = nursery
                ctx['daemon'] = nursery.start(ag.sleep_forever(), daemon=True)
                await ag.sleep_forever()

        ctx = {}
        root = ag.start(async_fn(ctx))
        nursery = ctx['nursery']
        daemon = ctx['daemon']
        self.assertEqual(root.state, TaskState.STARTED)
        self.assertEqual(daemon.state, TaskState.STARTED)
        self.assertFalse(nursery.closed)
        root._step()
        self.assertEqual(root.state, TaskState.FINISHED)
        self.assertEqual(daemon.state, TaskState.CANCELLED)
        self.assertTrue(nursery.closed)

    def test_finish_a_child_while_a_daemon_is_alive(self):
        async def async_fn(ctx):
            async with open_nursery() as nursery:
                ctx['nursery'] = nursery
                ctx['daemon'] = nursery.start(ag.sleep_forever(), daemon=True)
                ctx['child'] = nursery.start(ag.sleep_forever())

        ctx = {}
        root = ag.start(async_fn(ctx))
        nursery = ctx['nursery']
        daemon = ctx['daemon']
        child = ctx['child']
        self.assertEqual(root.state, TaskState.STARTED)
        self.assertEqual(daemon.state, TaskState.STARTED)
        self.assertEqual(child.state, TaskState.STARTED)
        self.assertFalse(nursery.closed)
        child._step()
        self.assertEqual(root.state, TaskState.FINISHED)
        self.assertEqual(daemon.state, TaskState.CANCELLED)
        self.assertEqual(child.state, TaskState.FINISHED)
        self.assertTrue(nursery.closed)

    def test_cancel_a_child_while_a_daemon_is_alive(self):
        async def async_fn(ctx):
            async with open_nursery() as nursery:
                ctx['nursery'] = nursery
                ctx['daemon'] = nursery.start(ag.sleep_forever(), daemon=True)
                ctx['child'] = nursery.start(ag.sleep_forever())

        ctx = {}
        root = ag.start(async_fn(ctx))
        nursery = ctx['nursery']
        daemon = ctx['daemon']
        child = ctx['child']
        self.assertEqual(root.state, TaskState.STARTED)
        self.assertEqual(daemon.state, TaskState.STARTED)
        self.assertEqual(child.state, TaskState.STARTED)
        self.assertFalse(nursery.closed)
        child.cancel()
        self.assertEqual(root.state, TaskState.FINISHED)
        self.assertEqual(daemon.state, TaskState.CANCELLED)
        self.assertEqual(child.state, TaskState.CANCELLED)
        self.assertTrue(nursery.closed)

    def test_finish_a_child_and_a_daemon_fails(self):
        async def fail_eventually():
            try:
                await ag.sleep_forever()
            finally:
                raise ZeroDivisionError

        async def async_fn(ctx):
            with pytest.raises(ExceptionGroup) as excinfo:
                async with open_nursery() as nursery:
                    ctx['nursery'] = nursery
                    ctx['daemon'] = nursery.start(fail_eventually(), daemon=True)
                    ctx['child'] = nursery.start(ag.sleep_forever())
                self.assertEqual([ZeroDivisionError], [type(e) for e in excinfo.value.exceptions])

        ctx = {}
        root = ag.start(async_fn(ctx))
        nursery = ctx['nursery']
        daemon = ctx['daemon']
        child = ctx['child']
        self.assertEqual(root.state, TaskState.STARTED)
        self.assertEqual(daemon.state, TaskState.STARTED)
        self.assertEqual(child.state, TaskState.STARTED)
        self.assertFalse(nursery.closed)
        child._step()
        self.assertEqual(root.state, TaskState.FINISHED)
        self.assertEqual(daemon.state, TaskState.CANCELLED)
        self.assertEqual(child.state, TaskState.FINISHED)
        self.assertTrue(nursery.closed)

    def test_finish_a_child_and_a_daemon_immediately_fails(self):
        async def fail_imm():
            raise ZeroDivisionError

        async def do_nothing():
            pass

        async def async_fn(ctx):
            with pytest.raises(ExceptionGroup) as excinfo:
                async with open_nursery() as nursery:
                    ctx['nursery'] = nursery
                    ctx['daemon'] = nursery.start(fail_imm(), daemon=True)
                    ctx['child'] = nursery.start(do_nothing())
                    await ag.sleep_forever()
                    pytest.fail()
                self.assertEqual([ZeroDivisionError], [type(e) for e in excinfo.value.exceptions])

        ctx = {}
        root = ag.start(async_fn(ctx))
        nursery = ctx['nursery']
        daemon = ctx['daemon']
        child = ctx['child']
        self.assertEqual(root.state, TaskState.FINISHED)
        self.assertEqual(daemon.state, TaskState.CANCELLED)
        self.assertEqual(child.state, TaskState.FINISHED)
        self.assertTrue(nursery.closed)

    def test_close_nursery(self):
        async def child2_func(nursery):
            await ag.sleep_forever()
            nursery.close()

        async def async_fn(ctx):
            async with open_nursery() as nursery:
                ctx['nursery'] = nursery
                ctx['child1'] = nursery.start(ag.sleep_forever())
                ctx['child2'] = nursery.start(child2_func(nursery))

        ctx = {}
        root = ag.start(async_fn(ctx))
        nursery = ctx['nursery']
        child1 = ctx['child1']
        child2 = ctx['child2']
        self.assertEqual(root.state, TaskState.STARTED)
        self.assertEqual(child1.state, TaskState.STARTED)
        self.assertEqual(child2.state, TaskState.STARTED)
        self.assertFalse(nursery.closed)
        child2._step()
        self.assertEqual(root.state, TaskState.FINISHED)
        self.assertEqual(child1.state, TaskState.CANCELLED)
        self.assertEqual(child2.state, TaskState.FINISHED)
        self.assertTrue(nursery.closed)

    def test_two_children(self):
        async def async_fn(ctx):
            async with open_nursery() as nursery:
                ctx['nursery'] = nursery
                ctx['child1'] = nursery.start(ag.sleep_forever())
                ctx['child2'] = nursery.start(ag.sleep_forever())

        ctx = {}
        root = ag.start(async_fn(ctx))
        nursery = ctx['nursery']
        child1 = ctx['child1']
        child2 = ctx['child2']
        self.assertEqual(root.state, TaskState.STARTED)
        self.assertEqual(child1.state, TaskState.STARTED)
        self.assertEqual(child2.state, TaskState.STARTED)
        self.assertFalse(nursery.closed)
        child1._step()
        self.assertEqual(root.state, TaskState.STARTED)
        self.assertEqual(child1.state, TaskState.FINISHED)
        self.assertEqual(child2.state, TaskState.STARTED)
        self.assertFalse(nursery.closed)
        child2._step()
        self.assertEqual(root.state, TaskState.FINISHED)
        self.assertEqual(child1.state, TaskState.FINISHED)
        self.assertEqual(child2.state, TaskState.FINISHED)
        self.assertTrue(nursery.closed)

    def test_parent_fails(self):
        async def fail_imm():
            raise ZeroDivisionError

        async def fail_eventually():
            try:
                await ag.sleep_forever()
            finally:
                raise ZeroDivisionError

        async def async_fn():
            with pytest.raises(ExceptionGroup) as excinfo:
                async with open_nursery() as nursery:
                    nursery.start(fail_imm(), daemon=True)
                    nursery.start(fail_eventually(), daemon=True)
                    nursery.start(fail_imm())
                    nursery.start(fail_eventually())
                    raise ZeroDivisionError
            self.assertEqual([ZeroDivisionError] * 5, [type(e) for e in excinfo.value.exceptions])

        root = ag.start(async_fn())
        self.assertTrue(root.finished)

    def test_garbage_collection(self):
        async def do_nothing():
            pass

        async def async_fn(ctx):
            async with open_nursery(_gc_in_every=3) as nursery:
                ctx['nursery'] = nursery
                nursery.start(ag.sleep_forever())
                nursery.start(do_nothing())
                nursery.start(ctx['e'].wait())

        ctx = {}
        ctx['e'] = e = ag.Event()
        root = ag.start(async_fn(ctx))
        nursery: ag.Nursery = ctx['nursery']
        self.assertEqual(len(nursery._children), 3)
        nursery.start(do_nothing())  # GC-ed
        self.assertEqual(len(nursery._children), 3)
        nursery.start(do_nothing())
        self.assertEqual(len(nursery._children), 4)
        e.fire()
        nursery.start(do_nothing())
        self.assertEqual(len(nursery._children), 5)
        nursery.start(do_nothing())  # GC-ed
        self.assertEqual(len(nursery._children), 2)
        nursery.close()
        self.assertTrue(root.finished)

if __name__ == '__main__':
    unittest.main()