Fix test_strict_compile depending on a warm __strict__ pyc

Summary:
`test_strict_compile` patched `StrictSourceFileLoader.source_to_code` to return
`None` class-wide, to prove that `a.py` is loaded from the pyc built by
`strict_compile()` rather than recompiled.  But `a.py` executes `import
__strict__`, which goes through that same patched loader, so the test only
passes when `__strict__` already has a valid cached pyc.

Under `ctr` the whole module runs in one process and an earlier test warms
`__strict__/__pycache__/__init__.cpython-314.strict.pyc`, so the test passes.
Under `buck test` each test method gets its own process against a cold
link-tree, so it always failed with:

  ImportError: Cannot import module __strict__; get_code() returned None

Scope the patch to `a.py` so the modules its body pulls in still compile
normally.

Reviewed By: yoney

Differential Revision: D116071905

fbshipit-source-id: 2e93b833ff3d1e4c1a3a9d8f21884e142f4d3f1c

Author: alexmalyshev

cinderx/PythonLib/test_cinderx/test_compiler/test_strict/test_loader.py

@@ -22,7 +22,7 @@
 from importlib.util import cache_from_source
 from os import path
 from py_compile import PycInvalidationMode
-from types import ModuleType
+from types import CodeType, ModuleType
 from typing import cast, final, List, TYPE_CHECKING, TypeVar
 from unittest.mock import patch
 
@@ -515,10 +515,23 @@ def test_strict_compile(self) -> None:
         fn = self.sbx.write_file("a.py", "import __strict__\nx = 2")
         strict_compile(str(fn), cache_from_source(fn))
 
-        # patch source_to_code on the loader to ensure we are loading from pyc
-        with patch.object(
-            StrictSourceFileLoader, "source_to_code", lambda *a, **kw: None
-        ):
+        orig_source_to_code = StrictSourceFileLoader.source_to_code
+
+        # Break compilation of 'a.py' only, so the test fails if it is not
+        # loaded from the pyc.  Modules pulled in by executing it, notably
+        # `__strict__` itself, still have to compile normally.
+        def source_to_code(
+            loader: StrictSourceFileLoader,
+            data: bytes | str,
+            path: str,
+            *,
+            _optimize: int = -1,
+        ) -> CodeType | None:
+            if path == str(fn):
+                return None
+            return orig_source_to_code(loader, data, path, _optimize=_optimize)
+
+        with patch.object(StrictSourceFileLoader, "source_to_code", source_to_code):
             mod = self.sbx.strict_import("a")
 
         self.assertEqual(type(mod), StrictModule)