示例#1
0
    def test_asyncio_run_reports_hanging_tasks_errors(self):
        lo_task = None
        call_exc_handler_mock = mock.Mock()

        async def leftover():
            try:
                await asyncio.sleep(0.1)
            except asyncio.CancelledError:
                1 / 0

        async def main():
            loop = asyncio.get_running_loop()
            loop.call_exception_handler = call_exc_handler_mock

            nonlocal lo_task
            lo_task = asyncio.create_task(leftover())
            return 123

        self.assertEqual(asyncio.run(main()), 123)
        self.assertTrue(lo_task.done())

        call_exc_handler_mock.assert_called_with({
            'message':
            test_utils.MockPattern(r'asyncio.run.*shutdown'),
            'task':
            lo_task,
            'exception':
            test_utils.MockInstanceOf(ZeroDivisionError)
        })
示例#2
0
 def test_fatal_error_connected(self, m_exc):
     transport = self.datagram_transport(address=('0.0.0.0', 1))
     err = ConnectionRefusedError()
     transport._fatal_error(err)
     self.assertFalse(self.protocol.error_received.called)
     m_exc.assert_called_with(test_utils.MockPattern(
         'Fatal error on transport\nprotocol:.*\ntransport:.*'),
                              exc_info=(ConnectionRefusedError, MOCK_ANY,
                                        MOCK_ANY))
示例#3
0
    def test_fatal_error(self, m_exc):
        exc = OSError()
        tr = self.create_transport()
        tr._force_close = mock.Mock()
        tr._fatal_error(exc)

        m_exc.assert_called_with(test_utils.MockPattern(
            'Fatal error on transport\nprotocol:.*\ntransport:.*'),
                                 exc_info=(OSError, MOCK_ANY, MOCK_ANY))

        tr._force_close.assert_called_with(exc)
    def test_fatal_error_connected_custom_error(self, m_exc):
        class MyException(Exception):
            pass

        transport = self.datagram_transport(address=('0.0.0.0', 1))
        err = MyException()
        transport._fatal_error(err)
        self.assertFalse(self.protocol.error_received.called)
        m_exc.assert_called_with(test_utils.MockPattern(
            'Fatal error on transport\nprotocol:.*\ntransport:.*'),
                                 exc_info=(MyException, MOCK_ANY, MOCK_ANY))
    def test_fatal_error_custom_exception(self, m_exc):
        class MyError(Exception):
            pass

        exc = MyError()
        tr = self.create_transport()
        tr._force_close = mock.Mock()
        tr._fatal_error(exc)

        m_exc.assert_called_with(test_utils.MockPattern(
            'Fatal error on transport\nprotocol:.*\ntransport:.*'),
                                 exc_info=(MyError, MOCK_ANY, MOCK_ANY))

        tr._force_close.assert_called_with(exc)