Fix refleaks in the test.

I can't add new testcases to test_multiprocessing_forkserver itself, i
had to put them within an existing _test_multiprocessing test class.  I
don't know why, but refleaks are fragile and that test suite is...
rediculiously complicated with all that it does.

Author: gpshead

Lib/multiprocessing/forkserver.py

@@ -106,6 +106,7 @@ def connect_to_new_process(self, fds):
                                 wrapped_client, self._forkserver_authkey)
                     finally:
                         wrapped_client._detach()
+                        del wrapped_client
                 reduction.sendfds(client, allfds)
                 return parent_r, parent_w
             except:

Lib/test/_test_multiprocessing.py

@@ -777,8 +777,8 @@ def test_error_on_stdio_flush_2(self):
                 finally:
                     setattr(sys, stream_name, old_stream)
 
-    @classmethod
-    def _sleep_and_set_event(self, evt, delay=0.0):
+    @staticmethod
+    def _sleep_and_set_event(evt, delay=0.0):
         time.sleep(delay)
         evt.set()
 
@@ -829,6 +829,68 @@ def test_forkserver_sigkill(self):
         if os.name != 'nt':
             self.check_forkserver_death(signal.SIGKILL)
 
+    @staticmethod
+    def _exit_process():
+        sys.exit(0)
+
+    def test_forkserver_auth_is_enabled(self):
+        if self.TYPE == "threads":
+            self.skipTest(f"test not appropriate for {self.TYPE}")
+        if multiprocessing.get_start_method() != "forkserver":
+            self.skipTest("forkserver start method specific")
+
+        forkserver = multiprocessing.forkserver._forkserver
+        forkserver.ensure_running()
+        self.assertTrue(forkserver._forkserver_pid)
+        authkey = forkserver._forkserver_authkey
+        self.assertTrue(authkey)
+        self.assertGreater(len(authkey), 15)
+        addr = forkserver._forkserver_address
+        self.assertTrue(addr)
+
+        # First, demonstrate that a raw auth handshake as Client makes
+        # does not raise an error.
+        client = multiprocessing.connection.Client(addr, authkey=authkey)
+        client.close()
+
+        # That worked, now launch a quick process.
+        proc = self.Process(target=self._exit_process)
+        proc.start()
+        proc.join()
+        self.assertEqual(proc.exitcode, 0)
+
+    def test_forkserver_without_auth_fails(self):
+        if self.TYPE == "threads":
+            self.skipTest(f"test not appropriate for {self.TYPE}")
+        if multiprocessing.get_start_method() != "forkserver":
+            self.skipTest("forkserver start method specific")
+
+        forkserver = multiprocessing.forkserver._forkserver
+        forkserver.ensure_running()
+        self.assertTrue(forkserver._forkserver_pid)
+        authkey_len = len(forkserver._forkserver_authkey)
+        with unittest.mock.patch.object(
+                forkserver, '_forkserver_authkey', None):
+            # With no auth handshake, the connection this makes to the
+            # forkserver will fail to do the file descriptor transfer
+            # over the pipe as the forkserver is expecting auth.
+            proc = self.Process(target=self._exit_process)
+            with self.assertRaisesRegex(RuntimeError, 'not receive ack'):
+                proc.start()
+            del proc
+
+            # With an incorrect authkey we should get an auth rejection
+            # rather than the above protocol error.
+            forkserver._forkserver_authkey = b'T'*authkey_len
+            proc = self.Process(target=self._exit_process)
+            with self.assertRaises(multiprocessing.AuthenticationError):
+                proc.start()
+            del proc
+
+        # authkey restored, launching processes should work again.
+        proc = self.Process(target=self._exit_process)
+        proc.start()
+        proc.join()
 
 #
 #

Lib/test/test_multiprocessing_forkserver.py

@@ -1,8 +1,6 @@
 import unittest
-from unittest import mock
 import test._test_multiprocessing
 
-import os
 import sys
 from test import support
 
@@ -12,56 +10,7 @@
 if sys.platform == "win32":
     raise unittest.SkipTest("forkserver is not available on Windows")
 
-import multiprocessing
-import multiprocessing.connection
-import multiprocessing.forkserver
-
 test._test_multiprocessing.install_tests_in_module_dict(globals(), 'forkserver')
 
-
-class TestForkserverControlAuthentication(unittest.TestCase):
-    def setUp(self):
-        super().setUp()
-        self.context = multiprocessing.get_context("forkserver")
-        self.pool = self.context.Pool(processes=1, maxtasksperchild=4)
-        self.assertEqual(self.pool.apply(eval, ("2+2",)), 4)
-        self.forkserver = multiprocessing.forkserver._forkserver
-        self.addr = self.forkserver._forkserver_address
-        self.assertTrue(self.addr)
-        self.authkey = self.forkserver._forkserver_authkey
-        self.assertGreater(len(self.authkey), 15)
-        self.assertTrue(self.forkserver._forkserver_pid)
-
-    def tearDown(self):
-        self.pool.terminate()
-        self.pool.join()
-        super().tearDown()
-
-    def test_auth_works(self):
-        """FYI: An 'EOFError: ran out of input' from a worker is normal."""
-        # First, demonstrate that a raw auth handshake as Client makes
-        # does not raise.
-        client = multiprocessing.connection.Client(
-                self.addr, authkey=self.authkey)
-        client.close()
-
-        # Now use forkserver code to do the same thing and more.
-        status_r, data_w = self.forkserver.connect_to_new_process([])
-        # It is normal for this to trigger an EOFError on stderr from the
-        # process... it is expecting us to send over a pickle of a Process
-        # instance to tell it what to do.
-        # If the authentication handshake and subsequent file descriptor
-        # sending dance had failed, an exception would've been raised.
-        os.close(data_w)
-        os.close(status_r)
-
-    def test_no_auth_fails(self):
-        with mock.patch.object(self.forkserver, '_forkserver_authkey', None):
-            # With no authkey set, the connection this makes will fail to
-            # do the file descriptor transfer over the pipe.
-            with self.assertRaisesRegex(RuntimeError, 'not receive ack'):
-                status_r, data_w = self.forkserver.connect_to_new_process([])
-
-
 if __name__ == '__main__':
     unittest.main()