test: Update interface_ipc.py after fixes from bitcoin-core/libmultiprocess#240

Author: ryanofsky

test/functional/interface_ipc.py

@@ -4,8 +4,6 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test the IPC (multiprocess) interface."""
 import asyncio
-import http.client
-import re
 
 from contextlib import ExitStack
 from test_framework.test_framework import BitcoinTestFramework
@@ -89,9 +87,9 @@ async def async_routine():
 =======
     def run_unclean_disconnect_test(self):
         """Test behavior when disconnecting during an IPC call that later
-        returns a non-null interface pointer. Currently this behavior causes a
-        crash as reported https://github.com/bitcoin/bitcoin/issues/34250, but a
-        followup will change this behavior."""
+        returns a non-null interface pointer. This used to cause a crash as
+        reported https://github.com/bitcoin/bitcoin/issues/34250, but now just
+        results in a cancellation log message"""
         node = self.nodes[0]
         self.log.info("Running disconnect during BlockTemplate.waitNext")
         timeout = self.rpc_timeout * 1000.0
@@ -116,28 +114,22 @@ async def async_routine():
             with node.assert_debug_log(expected_msgs=["BlockTemplate.waitNext", "IPC server post request"], timeout=2):
                 promise = template.waitNext(ctx, waitoptions)
                 await asyncio.sleep(0.1)
-            disconnected_log_check.enter_context(node.assert_debug_log(expected_msgs=["IPC server: socket disconnected"], timeout=2))
+            disconnected_log_check.enter_context(node.assert_debug_log(expected_msgs=["IPC server: socket disconnected", "canceled while executing"], timeout=2))
             del promise
 
         asyncio.run(capnp.run(async_routine()))
 
         # Wait for socket disconnected log message, then generate a block to
-        # cause the waitNext() call to return a new template. This will cause a
-        # crash and disconnect with error output.
-        disconnected_log_check.close()
-        try:
+        # cause the waitNext() call to return a new template. Look for a
+        # canceled IPC log message after waitNext returns.
+        with node.assert_debug_log(expected_msgs=["interrupted (canceled)"]):
+            disconnected_log_check.close()
             self.generate(node, 1)
-        except (http.client.RemoteDisconnected, BrokenPipeError, ConnectionResetError):
-            pass
-        node.wait_until_stopped(expected_ret_code=(-11, -6, 1, 66), expected_stderr=re.compile(""))
-        self.start_node(0)
 
     def run_thread_busy_test(self):
         """Test behavior when sending multiple calls to the same server thread
         which used to cause a crash as reported
-        https://github.com/bitcoin/bitcoin/issues/33923 and currently causes a
-        thread busy error. A future change will make this just queue the calls
-        for execution and not trigger any error"""
+        https://github.com/bitcoin/bitcoin/issues/33923."""
         node = self.nodes[0]
         self.log.info("Running thread busy test")
         timeout = self.rpc_timeout * 1000.0
@@ -168,19 +160,16 @@ async def async_routine():
             with node.assert_debug_log(expected_msgs=["BlockTemplate.waitNext", "IPC server post request"], timeout=2):
                 promise2 = template.waitNext(ctx, waitoptions)
                 await asyncio.sleep(0.1)
-            try:
-                await template.waitNext(ctx, waitoptions)
-            except capnp.lib.capnp.KjException as e:
-                assert_equal(e.description, "remote exception: std::exception: thread busy")
-                assert_equal(e.type, "FAILED")
-            else:
-                raise AssertionError("Expected thread busy exception")
+            with node.assert_debug_log(expected_msgs=["BlockTemplate.waitNext", "IPC server post request"]):
+                promise3 = template.waitNext(ctx, waitoptions)
+                await asyncio.sleep(0.1)
 
             # Generate a new block to make the active waitNext calls return, then clean up.
             with node.assert_debug_log(expected_msgs=["IPC server send response"], timeout=2):
                 self.generate(node, 1, sync_fun=self.no_op)
             await ((await promise1).result).destroy(ctx)
             await ((await promise2).result).destroy(ctx)
+            await ((await promise3).result).destroy(ctx)
             await template.destroy(ctx)
 
         asyncio.run(capnp.run(async_routine()))