Move some tests away from using subprocess.run

Summary:
subprocess.run isn't supported in buck tests. We have a bunch of tests that are using it. They don't work when we run as a par on Python 3.15 and they're now failing on the nightly 3.14 runs where we're presumably picking up the system Python in combination w/ native python.

This moves some of the offending tests away from using subprocess.run.

Reviewed By: alexmalyshev

Differential Revision: D90211488

fbshipit-source-id: 233445ca5e53bfa6279dcda264c5907e8f4c9595

Author: DinoV

cinderx/PythonLib/test_cinderx/test_jit_disable.py

@@ -2,10 +2,8 @@
 
 # pyre-unsafe
 
-import subprocess
+import multiprocessing
 import sys
-import tempfile
-import textwrap
 import unittest
 from pathlib import Path
 
@@ -207,183 +205,162 @@ 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.
         """
 
-        with tempfile.TemporaryDirectory() as tmp_dir:
-            code = textwrap.dedent("""
-            import cinderx.jit
+        p = multiprocessing.Process(target=DisableEnableTests.compile_no_config_test)
+        p.start()
+        p.join()
+        self.assertEqual(p.exitcode, 0)
 
-            def inc(x):
-                return x + 1
+    @staticmethod
+    def auto_test() -> None:
+        import cinderx.jit
 
-            assert not cinderx.jit.is_jit_compiled(inc)
-            cinderx.jit.force_compile(inc)
-            assert cinderx.jit.is_jit_compiled(inc)
-            """)
+        def predefined(x):
+            return x + x
 
-            test_file = Path(tmp_dir) / "mod.py"
-            test_file.write_text(code)
+        cinderx.jit.auto()
 
-            subprocess.run(
-                [sys.executable, str(test_file)],
-                check=True,
-                env={"PYTHONPATH": CINDERX_PATH},
-            )
+        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)
 
     def test_auto(self) -> None:
         """
         Basic test for cinderx.jit.auto().
         """
 
-        with tempfile.TemporaryDirectory() as tmp_dir:
-            code = textwrap.dedent("""
-            import cinderx.jit
-
-            def predefined(x):
-                return x + x
+        p = multiprocessing.Process(target=DisableEnableTests.auto_test)
+        p.start()
+        p.join()
+        self.assertEqual(p.exitcode, 0)
 
-            cinderx.jit.auto()
+    @staticmethod
+    def auto_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)
-            for i in range(1000):
-                inc(i)
-            assert not cinderx.jit.is_jit_compiled(inc)
+        cinderx.jit.auto()
 
-            inc(1001)
-            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)
 
-            test_file = Path(tmp_dir) / "mod.py"
-            test_file.write_text(code)
-
-            subprocess.run(
-                [sys.executable, str(test_file)],
-                check=True,
-                env={"PYTHONPATH": CINDERX_PATH},
-            )
+        predefined(1001)
+        assert cinderx.jit.is_jit_compiled(predefined)
 
     def test_auto_predefined(self) -> None:
         """
         Test that cinderx.jit.auto() works for functions that were defined
         before it was called.
         """
 
-        with tempfile.TemporaryDirectory() as tmp_dir:
-            code = textwrap.dedent("""
-            import cinderx.jit
-
-            def predefined(x):
-                return x + x
+        p = multiprocessing.Process(target=DisableEnableTests.auto_predefined_test)
+        p.start()
+        p.join()
+        self.assertEqual(p.exitcode, 0)
 
-            cinderx.jit.auto()
+    @staticmethod
+    def compile_after_n_calls_test() -> None:
+        import cinderx.jit
 
-            assert not cinderx.jit.is_jit_compiled(predefined)
-            for i in range(1000):
-                predefined(i)
-            assert not cinderx.jit.is_jit_compiled(predefined)
+        cinderx.jit.compile_after_n_calls(2)
 
-            predefined(1001)
-            assert cinderx.jit.is_jit_compiled(predefined)
-            """)
+        def inc(x):
+            return x + 1
 
-            test_file = Path(tmp_dir) / "mod.py"
-            test_file.write_text(code)
+        assert not cinderx.jit.is_jit_compiled(inc)
+        inc(1)
+        inc(2)
+        assert not cinderx.jit.is_jit_compiled(inc)
 
-            subprocess.run(
-                [sys.executable, str(test_file)],
-                check=True,
-                env={"PYTHONPATH": CINDERX_PATH},
-            )
+        inc(3)
+        assert cinderx.jit.is_jit_compiled(inc)
 
-    def test_compile_after_n_calls(self) -> None:
-        """
-        Basic test for cinderx.jit.compile_after_n_calls().
-        """
+        # Change the setting and see it takes affect.
 
-        with tempfile.TemporaryDirectory() as tmp_dir:
-            code = textwrap.dedent("""
-            import cinderx.jit
+        cinderx.jit.compile_after_n_calls(5)
 
-            cinderx.jit.compile_after_n_calls(2)
+        def dec(x):
+            return x - 1
 
-            def inc(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)
 
-            assert not cinderx.jit.is_jit_compiled(inc)
-            inc(1)
-            inc(2)
-            assert not cinderx.jit.is_jit_compiled(inc)
+        dec(6)
+        assert cinderx.jit.is_jit_compiled(dec)
 
-            inc(3)
-            assert cinderx.jit.is_jit_compiled(inc)
-
-            # Change the setting and see it takes affect.
+    def test_compile_after_n_calls(self) -> None:
+        """
+        Basic test for cinderx.jit.compile_after_n_calls().
+        """
 
-            cinderx.jit.compile_after_n_calls(5)
+        p = multiprocessing.Process(
+            target=DisableEnableTests.compile_after_n_calls_test
+        )
+        p.start()
+        p.join()
+        self.assertEqual(p.exitcode, 0)
 
-            def dec(x):
-                return x - 1
+    @staticmethod
+    def compile_after_n_calls_predefined_test() -> None:
+        import cinderx.jit
 
-            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)
+        def predefined(x):
+            return x + x
 
-            dec(6)
-            assert cinderx.jit.is_jit_compiled(dec)
-            """)
+        cinderx.jit.compile_after_n_calls(2)
 
-            test_file = Path(tmp_dir) / "mod.py"
-            test_file.write_text(code)
+        assert not cinderx.jit.is_jit_compiled(predefined)
+        predefined(1)
+        predefined(2)
+        assert not cinderx.jit.is_jit_compiled(predefined)
 
-            subprocess.run(
-                [sys.executable, str(test_file)],
-                check=True,
-                env={"PYTHONPATH": CINDERX_PATH},
-            )
+        predefined(3)
+        assert cinderx.jit.is_jit_compiled(predefined)
 
     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.
         """
 
-        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={"PYTHONPATH": CINDERX_PATH},
-            )
+        p = multiprocessing.Process(
+            target=DisableEnableTests.compile_after_n_calls_predefined_test
+        )
+        p.start()
+        p.join()
+        self.assertEqual(p.exitcode, 0)
 
 
 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
 
@@ -171,40 +171,29 @@ def test_batch_compile_nested_func(self) -> None:
         self.assertEqual(proc.returncode, 0, proc.stderr)
         self.assertEqual(b"42\n", proc.stdout, proc.stdout)
 
-    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
+    @staticmethod
+    def precompile_all_test() -> None:
+        import cinderx.jit
 
-            def func():
-                return 24
+        def func() -> int:
+            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)
 
-            print(func())
-        """
-        )
+        assert func() == 24
 
-        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={"PYTHONPATH": CINDERX_PATH},
-            )
-        self.assertEqual(proc.returncode, 0, proc)
-        self.assertEqual(proc.stdout.strip(), "24")
+    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)
 
     def test_read_jit_list(self) -> None:
         def victim() -> None: