fix: don't disable Actor exit_process just because scrapy is importable

Author: vdusek

docs/02_concepts/01_actor_lifecycle.mdx

@@ -48,7 +48,7 @@ You can also create an <ApiLink to="class/Actor">`Actor`</ApiLink> instance dire
 
 - `configuration` — a custom <ApiLink to="class/Configuration">`Configuration`</ApiLink> instance to control storage paths, API URLs, and other settings.
 - `configure_logging` — whether to set up default logging configuration (default `True`). Set to `False` if you configure logging yourself.
-- `exit_process` — whether the Actor calls `sys.exit()` when the context manager exits. Defaults to `True`, except in IPython, Pytest, and Scrapy environments.
+- `exit_process` — whether the Actor calls `sys.exit()` when the context manager exits. Defaults to `True`, except in IPython and Scrapy environments.
 - `event_listeners_timeout` — maximum time to wait for Actor event listeners to complete before exiting.
 - `cleanup_timeout` — maximum time to wait for cleanup tasks to finish (default 30 seconds).
 

src/apify/_actor.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 import asyncio
+import os
 import sys
 import warnings
-from contextlib import suppress
 from dataclasses import asdict
 from datetime import UTC, datetime, timedelta
 from functools import cached_property
@@ -1441,10 +1441,11 @@ def _get_default_exit_process(self) -> bool:
             self.log.debug('Running in IPython, setting default `exit_process` to False.')
             return False
 
-        # Check if running in Scrapy by attempting to import it.
-        with suppress(ImportError):
-            import scrapy  # noqa: F401 PLC0415
-
+        # Detect an actual Scrapy project via the `SCRAPY_SETTINGS_MODULE` environment variable (set by the
+        # Scrapy CLI and by `apify.scrapy.run_scrapy_actor`), not by whether `scrapy` merely happens to be
+        # importable. Otherwise any image where Scrapy is a transitive dependency would silently disable the
+        # `sys.exit()` on Actor exit, so a failed run could end with exit code 0 and be marked as succeeded.
+        if os.environ.get('SCRAPY_SETTINGS_MODULE'):
             self.log.debug('Running in Scrapy, setting default `exit_process` to False.')
             return False
 

tests/unit/actor/test_actor_lifecycle.py

@@ -18,14 +18,13 @@
 
 from ..._utils import poll_until_condition
 from apify import Actor
+from apify._actor import _ActorType
 from apify._charging import ChargingManagerImplementation
 from apify._consts import EXIT_CODE_ERROR_USER_FUNCTION_THREW, ActorEnvVars, ApifyEnvVars
 
 if TYPE_CHECKING:
     from collections.abc import AsyncGenerator, Callable
 
-    from apify._actor import _ActorType
-
 
 @pytest.fixture(
     params=[
@@ -199,6 +198,27 @@ async def test_unhandled_exception_sets_error_exit_code() -> None:
     assert actor.exit_code == EXIT_CODE_ERROR_USER_FUNCTION_THREW
 
 
+# The autouse `_isolate_test_environment` fixture forces the `exit_process` default to False so a clean
+# context exit does not call `sys.exit()`. Capture the genuine detector at import time and call it
+# directly so these tests exercise the real logic rather than the test-environment override.
+_detect_default_exit_process = _ActorType._get_default_exit_process
+
+
+def test_default_exit_process_true_when_scrapy_importable_but_not_running(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Regression for B7: `scrapy` merely being importable must not disable `exit_process`."""
+    pytest.importorskip('scrapy')
+    monkeypatch.delenv('SCRAPY_SETTINGS_MODULE', raising=False)
+    actor = Actor(exit_process=False)
+    assert _detect_default_exit_process(actor) is True
+
+
+def test_default_exit_process_false_when_running_under_scrapy(monkeypatch: pytest.MonkeyPatch) -> None:
+    """The Scrapy runner sets `SCRAPY_SETTINGS_MODULE`, which must disable `exit_process` by default."""
+    monkeypatch.setenv('SCRAPY_SETTINGS_MODULE', 'src.settings')
+    actor = Actor(exit_process=False)
+    assert _detect_default_exit_process(actor) is False
+
+
 async def test_actor_stops_periodic_events_after_exit(monkeypatch: pytest.MonkeyPatch) -> None:
     """Test that periodic events (PERSIST_STATE and SYSTEM_INFO) stop emitting after Actor exits."""
     monkeypatch.setenv(ApifyEnvVars.SYSTEM_INFO_INTERVAL_MILLIS, '100')

tests/unit/conftest.py

@@ -60,6 +60,12 @@ def prepare_test_env(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> Callabl
     """
 
     def _prepare_test_env() -> None:
+        # Production code deliberately does not detect the test environment (see issue #641), so force the
+        # `exit_process` default to False here. Otherwise a clean Actor context exit would call `sys.exit()`
+        # and abort the test. Tests that need a specific value pass `exit_process` explicitly. Patch before
+        # touching the `Actor` proxy below, since that materializes its `_ActorType` instance.
+        monkeypatch.setattr(apify._actor._ActorType, '_get_default_exit_process', lambda _self: False)
+
         if hasattr(apify._actor.Actor, '__wrapped__'):
             delattr(apify._actor.Actor, '__wrapped__')