Back out "Move some tests away from using subprocess.run"

Summary:
We've found a better way to deal with this than using multiprocessing, and the multiprocessing version is still failing when we have binary incompatibilities between the platform runtime and the bundled runtime. This switches back to subprocess.run with the new `subprocess_env`.

Original Phabricator Diff: D90211488

Reviewed By: czardoz

Differential Revision: D91907006

fbshipit-source-id: 0f7b162bdebad368126bbcc6386f60677fdd907d

Author: DinoV

cinderx/PythonLib/test_cinderx/test_jit_disable.py

@@ -2,8 +2,10 @@
 
 # pyre-unsafe
 
-import multiprocessing
+import subprocess
 import sys
+import tempfile
+import textwrap
 import unittest
 from pathlib import Path
 
@@ -19,7 +21,7 @@
     lazy_compile,
     pause as pause_jit,
 )
-from cinderx.test_support import passUnless
+from cinderx.test_support import passUnless, subprocess_env
 
 
 @passUnless(is_jit_enabled(), "Tests functionality on the JIT")
@@ -204,162 +206,183 @@ def foo(a, b):
         # detection.
         force_uncompile(foo)
 
-    @staticmethod
-    def compile_no_config_test() -> None:
-        import cinderx.jit
-
-        def inc(x):
-            return x + 1
-
-        assert not cinderx.jit.is_jit_compiled(inc)
-        cinderx.jit.force_compile(inc)
-        assert cinderx.jit.is_jit_compiled(inc)
-
     def test_compile_no_config(self) -> None:
         """
         Test how code behaves when it forces compilation without any other
         configuration or options enabled.
         """
 
-        p = multiprocessing.Process(target=DisableEnableTests.compile_no_config_test)
-        p.start()
-        p.join()
-        self.assertEqual(p.exitcode, 0)
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            code = textwrap.dedent("""
+            import cinderx.jit
 
-    @staticmethod
-    def auto_test() -> None:
-        import cinderx.jit
+            def inc(x):
+                return x + 1
 
-        def predefined(x):
-            return x + x
+            assert not cinderx.jit.is_jit_compiled(inc)
+            cinderx.jit.force_compile(inc)
+            assert cinderx.jit.is_jit_compiled(inc)
+            """)
 
-        cinderx.jit.auto()
+            test_file = Path(tmp_dir) / "mod.py"
+            test_file.write_text(code)
 
-        def inc(x):
-            return x + 1
-
-        assert not cinderx.jit.is_jit_compiled(inc)
-        for i in range(1000):
-            inc(i)
-        assert not cinderx.jit.is_jit_compiled(inc)
-
-        inc(1001)
-        assert cinderx.jit.is_jit_compiled(inc)
+            subprocess.run(
+                [sys.executable, str(test_file)],
+                check=True,
+                env=subprocess_env(),
+            )
 
     def test_auto(self) -> None:
         """
         Basic test for cinderx.jit.auto().
         """
 
-        p = multiprocessing.Process(target=DisableEnableTests.auto_test)
-        p.start()
-        p.join()
-        self.assertEqual(p.exitcode, 0)
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            code = textwrap.dedent("""
+            import cinderx.jit
+
+            def predefined(x):
+                return x + x
 
-    @staticmethod
-    def auto_predefined_test() -> None:
-        import cinderx.jit
+            cinderx.jit.auto()
 
-        def predefined(x):
-            return x + x
+            def inc(x):
+                return x + 1
 
-        cinderx.jit.auto()
+            assert not cinderx.jit.is_jit_compiled(inc)
+            for i in range(1000):
+                inc(i)
+            assert not cinderx.jit.is_jit_compiled(inc)
 
-        assert not cinderx.jit.is_jit_compiled(predefined)
-        for i in range(1000):
-            predefined(i)
-        assert not cinderx.jit.is_jit_compiled(predefined)
+            inc(1001)
+            assert cinderx.jit.is_jit_compiled(inc)
+            """)
 
-        predefined(1001)
-        assert cinderx.jit.is_jit_compiled(predefined)
+            test_file = Path(tmp_dir) / "mod.py"
+            test_file.write_text(code)
+
+            subprocess.run(
+                [sys.executable, str(test_file)],
+                check=True,
+                env=subprocess_env(),
+            )
 
     def test_auto_predefined(self) -> None:
         """
         Test that cinderx.jit.auto() works for functions that were defined
         before it was called.
         """
 
-        p = multiprocessing.Process(target=DisableEnableTests.auto_predefined_test)
-        p.start()
-        p.join()
-        self.assertEqual(p.exitcode, 0)
-
-    @staticmethod
-    def compile_after_n_calls_test() -> None:
-        import cinderx.jit
-
-        cinderx.jit.compile_after_n_calls(2)
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            code = textwrap.dedent("""
+            import cinderx.jit
 
-        def inc(x):
-            return x + 1
+            def predefined(x):
+                return x + x
 
-        assert not cinderx.jit.is_jit_compiled(inc)
-        inc(1)
-        inc(2)
-        assert not cinderx.jit.is_jit_compiled(inc)
+            cinderx.jit.auto()
 
-        inc(3)
-        assert cinderx.jit.is_jit_compiled(inc)
+            assert not cinderx.jit.is_jit_compiled(predefined)
+            for i in range(1000):
+                predefined(i)
+            assert not cinderx.jit.is_jit_compiled(predefined)
 
-        # Change the setting and see it takes affect.
+            predefined(1001)
+            assert cinderx.jit.is_jit_compiled(predefined)
+            """)
 
-        cinderx.jit.compile_after_n_calls(5)
+            test_file = Path(tmp_dir) / "mod.py"
+            test_file.write_text(code)
 
-        def dec(x):
-            return x - 1
-
-        assert not cinderx.jit.is_jit_compiled(dec)
-        dec(1)
-        dec(2)
-        dec(3)
-        dec(4)
-        dec(5)
-        assert not cinderx.jit.is_jit_compiled(dec)
-
-        dec(6)
-        assert cinderx.jit.is_jit_compiled(dec)
+            subprocess.run(
+                [sys.executable, str(test_file)],
+                check=True,
+                env=subprocess_env(),
+            )
 
     def test_compile_after_n_calls(self) -> None:
         """
         Basic test for cinderx.jit.compile_after_n_calls().
         """
 
-        p = multiprocessing.Process(
-            target=DisableEnableTests.compile_after_n_calls_test
-        )
-        p.start()
-        p.join()
-        self.assertEqual(p.exitcode, 0)
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            code = textwrap.dedent("""
+            import cinderx.jit
+
+            cinderx.jit.compile_after_n_calls(2)
 
-    @staticmethod
-    def compile_after_n_calls_predefined_test() -> None:
-        import cinderx.jit
+            def inc(x):
+                return x + 1
 
-        def predefined(x):
-            return x + x
+            assert not cinderx.jit.is_jit_compiled(inc)
+            inc(1)
+            inc(2)
+            assert not cinderx.jit.is_jit_compiled(inc)
 
-        cinderx.jit.compile_after_n_calls(2)
+            inc(3)
+            assert cinderx.jit.is_jit_compiled(inc)
 
-        assert not cinderx.jit.is_jit_compiled(predefined)
-        predefined(1)
-        predefined(2)
-        assert not cinderx.jit.is_jit_compiled(predefined)
+            # Change the setting and see it takes affect.
 
-        predefined(3)
-        assert cinderx.jit.is_jit_compiled(predefined)
+            cinderx.jit.compile_after_n_calls(5)
+
+            def dec(x):
+                return x - 1
+
+            assert not cinderx.jit.is_jit_compiled(dec)
+            dec(1)
+            dec(2)
+            dec(3)
+            dec(4)
+            dec(5)
+            assert not cinderx.jit.is_jit_compiled(dec)
+
+            dec(6)
+            assert cinderx.jit.is_jit_compiled(dec)
+            """)
+
+            test_file = Path(tmp_dir) / "mod.py"
+            test_file.write_text(code)
+
+            subprocess.run(
+                [sys.executable, str(test_file)],
+                check=True,
+                env=subprocess_env(),
+            )
 
     def test_compile_after_n_calls_predefined(self) -> None:
         """
         Test that cinderx.jit.compile_after_n_calls() works for functions that
         were defined before it was called.
         """
 
-        p = multiprocessing.Process(
-            target=DisableEnableTests.compile_after_n_calls_predefined_test
-        )
-        p.start()
-        p.join()
-        self.assertEqual(p.exitcode, 0)
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            code = textwrap.dedent("""
+            import cinderx.jit
+
+            def predefined(x):
+                return x + x
+
+            cinderx.jit.compile_after_n_calls(2)
+
+            assert not cinderx.jit.is_jit_compiled(predefined)
+            predefined(1)
+            predefined(2)
+            assert not cinderx.jit.is_jit_compiled(predefined)
+
+            predefined(3)
+            assert cinderx.jit.is_jit_compiled(predefined)
+            """)
+
+            test_file = Path(tmp_dir) / "mod.py"
+            test_file.write_text(code)
+
+            subprocess.run(
+                [sys.executable, str(test_file)],
+                check=True,
+                env=subprocess_env(),
+            )
 
 
 if __name__ == "__main__":

cinderx/PythonLib/test_cinderx/test_jitlist.py

@@ -4,11 +4,11 @@
 
 # This is in its own file as it modifies the global JIT-list.
 
-import multiprocessing
 import os
 import subprocess
 import sys
 import tempfile
+import textwrap
 import unittest
 from pathlib import Path
 
@@ -170,29 +170,40 @@ def test_batch_compile_nested_func(self) -> None:
         self.assertEqual(proc.returncode, 0, proc.stderr)
         self.assertEqual(b"42\n", proc.stdout, proc.stdout)
 
-    @staticmethod
-    def precompile_all_test() -> None:
-        import cinderx.jit
+    def test_precompile_all(self) -> None:
+        # Has to be run under a separate process because precompile_all will mess up the
+        # other JIT-related tests.
+        code = textwrap.dedent(
+            """
+            import cinderx.jit
 
-        def func() -> int:
-            return 24
+            def func():
+                return 24
 
-        assert not cinderx.jit.is_jit_compiled(func)
-        cinderx.jit.lazy_compile(func)
-        assert not cinderx.jit.is_jit_compiled(func)
+            assert not cinderx.jit.is_jit_compiled(func)
+            cinderx.jit.lazy_compile(func)
+            assert not cinderx.jit.is_jit_compiled(func)
 
-        assert cinderx.jit.precompile_all(workers=2)
-        assert cinderx.jit.is_jit_compiled(func)
+            assert cinderx.jit.precompile_all(workers=2)
+            assert cinderx.jit.is_jit_compiled(func)
 
-        assert func() == 24
+            print(func())
+        """
+        )
 
-    def test_precompile_all(self) -> None:
-        # Has to be run under a separate process because precompile_all will mess up the
-        # other JIT-related tests.
-        p = multiprocessing.Process(target=JitListTest.precompile_all_test)
-        p.start()
-        p.join()
-        self.assertEqual(p.exitcode, 0)
+        with tempfile.TemporaryDirectory() as tmp:
+            dirpath = Path(tmp)
+            codepath = dirpath / "mod.py"
+            codepath.write_text(code)
+            proc = subprocess.run(
+                [sys.executable, "mod.py"],
+                stdout=subprocess.PIPE,
+                cwd=tmp,
+                encoding=ENCODING,
+                env=subprocess_env(),
+            )
+        self.assertEqual(proc.returncode, 0, proc)
+        self.assertEqual(proc.stdout.strip(), "24")
 
     def test_read_jit_list(self) -> None:
         def victim() -> None: