test: pull in conftest isolation improvements from Henrik/test-pr-297

- restore_flash_sys_modules autouse fixture: snapshots and restores
  runpod_flash.* sys.modules entries after each test, preventing class
  identity splits under -n auto
- stale state file cleanup in reset_singletons: deletes corrupt/partial
  .flash/resources.pkl before each test so it cannot poison the next worker
- fix test_serialization_error_handling: update docstring to reflect AE-2370
  behaviour (caching non-fatal, method call still raises SerializationError)

Author: runpod-Henrik

tests/conftest.py

@@ -267,6 +267,32 @@ def worker_flash_dir(worker_temp_dir: Path) -> Path:
     return flash_dir
 
 
+@pytest.fixture(autouse=True)
+def restore_flash_sys_modules():
+    """Restore sys.modules entries for runpod_flash after each test.
+
+    Tests that call importlib.reload() or delete runpod_flash entries from
+    sys.modules leave stale or reloaded class objects in the interpreter.
+    Subsequent tests on the same worker then see different class objects for
+    the same class (e.g. LiveServerlessMixin, _ClientCoroutine), causing
+    isinstance() to return False even when the type looks correct.
+
+    This fixture snapshots all runpod_flash.* entries before the test and
+    restores them after, keeping the module registry clean regardless of what
+    the test does to sys.modules.
+    """
+    import sys
+
+    saved = {k: v for k, v in sys.modules.items() if k.startswith("runpod_flash")}
+    yield
+    # Remove any entries added or replaced during the test
+    for k in list(sys.modules.keys()):
+        if k.startswith("runpod_flash"):
+            del sys.modules[k]
+    # Restore the snapshot
+    sys.modules.update(saved)
+
+
 @pytest.fixture(autouse=True)
 def isolate_resource_state_file(
     monkeypatch: pytest.MonkeyPatch, worker_flash_dir: Path
@@ -315,6 +341,15 @@ def reset_singletons():
     This fixture runs automatically for all tests to ensure
     clean state between test executions.
     """
+    # Delete stale state file before each test so that a corrupt or partially-
+    # written pickle from a previous test cannot poison the ResourceManager of
+    # the next test in the same worker.
+    from runpod_flash.core.resources import resource_manager as _rm_module
+
+    _state_file = _rm_module.RESOURCE_STATE_FILE
+    if _state_file.exists():
+        _state_file.unlink(missing_ok=True)
+
     # Patch cloudpickle to handle threading.Lock objects that may be left over
     # from previous tests. This prevents "cannot pickle '_thread.lock'" errors
     # when test pollution causes old lock instances to be in the object graph.

tests/integration/test_class_execution_integration.py

@@ -18,6 +18,7 @@
 from runpod_flash.client import remote
 from runpod_flash.core.resources import ServerlessResource
 from runpod_flash.execute_class import create_remote_class
+from runpod_flash.runtime.exceptions import SerializationError
 
 
 @patch.dict(os.environ, {"RUNPOD_ENDPOINT_ID": "", "RUNPOD_POD_ID": ""})
@@ -606,7 +607,13 @@ async def mock_failing_ensure_initialized():
 
     @pytest.mark.asyncio
     async def test_serialization_error_handling(self):
-        """Test error handling for serialization issues."""
+        """Test error handling for serialization issues.
+
+        AE-2370 (v1.11.3): constructor arg *caching* is non-fatal — a warning is
+        logged and the cache entry is skipped. However, the method call itself still
+        raises SerializationError when the args cannot be serialized at call time,
+        because the fallback path (execute_class.py:272) also calls serialize_args.
+        """
 
         class UnserializableClass:
             def __init__(self, file_handle=None):
@@ -615,18 +622,15 @@ def __init__(self, file_handle=None):
             def process_file(self):
                 return "Processing file"
 
-        # Create instance with unserializable object
         import tempfile
 
         with tempfile.NamedTemporaryFile() as temp_file:
             RemoteUnserializableClass = create_remote_class(
                 UnserializableClass, self.mock_resource_config, [], [], True
             )
 
-            # This should not fail during initialization (lazy serialization)
             instance = RemoteUnserializableClass(temp_file)
 
-            # Mock ensure_initialized to avoid actual resource calls
             mock_stub = AsyncMock()
 
             async def mock_ensure_initialized():
@@ -638,14 +642,11 @@ async def mock_ensure_initialized():
             with patch.object(
                 instance, "_ensure_initialized", side_effect=mock_ensure_initialized
             ):
-                # The error should occur during method call when trying to serialize
-                # Mock cloudpickle.dumps to raise an error
-                from runpod_flash.runtime.exceptions import SerializationError
-
                 with patch(
                     "runpod_flash.runtime.serialization.cloudpickle.dumps",
                     side_effect=TypeError("Can't pickle file objects"),
                 ):
+                    # Caching is skipped with warnings (AE-2370); method call still raises
                     with pytest.raises(
                         SerializationError, match="Can't pickle file objects"
                     ):