more and better tests

Author: vdusek

tests/unit/actor/test_actor_lifecycle.py

@@ -5,64 +5,185 @@
 import json
 import sys
 from datetime import datetime, timezone
-from typing import TYPE_CHECKING, Any, cast
+from typing import TYPE_CHECKING, Any
 from unittest import mock
 from unittest.mock import AsyncMock, Mock
 
 import pytest
 import websockets.asyncio.server
 
-from apify_shared.consts import ActorEnvVars, ApifyEnvVars
+from apify_shared.consts import ActorEnvVars, ActorExitCodes, ApifyEnvVars
 from crawlee.events._types import Event, EventPersistStateData
 
-import apify._actor
 from apify import Actor
 
 if TYPE_CHECKING:
-    from collections.abc import Callable
+    from collections.abc import AsyncGenerator, Callable
+
+    from apify._actor import _ActorType
+
+
+@pytest.fixture(
+    params=[
+        pytest.param(('instance', 'manual'), id='instance-manual'),
+        pytest.param(('instance', 'async_with'), id='instance-async-with'),
+        pytest.param(('class', 'manual'), id='class-manual'),
+        pytest.param(('class', 'async_with'), id='class-async-with'),
+    ]
+)
+async def actor(
+    request: pytest.FixtureRequest,
+) -> AsyncGenerator[_ActorType, None]:
+    """Yield Actor instance or class in different initialization modes.
+
+    - instance-manual: Actor() with manual init()/exit()
+    - instance-async-with: Actor() used as async context manager
+    - class-manual: Actor class with manual init()/exit()
+    - class-async-with: Actor class used as async context manager
+
+    Each Actor is properly initialized before yielding and cleaned up after.
+    """
+    scope, mode = request.param
+
+    if scope == 'instance':
+        if mode == 'manual':
+            instance = Actor()
+            await instance.init()
+            yield instance
+            await instance.exit()
+        else:
+            async with Actor() as instance:
+                yield instance
+
+    elif scope == 'class':
+        if mode == 'manual':
+            await Actor.init()
+            yield Actor
+            await Actor.exit()
+        else:
+            async with Actor:
+                yield Actor
 
-    from lazy_object_proxy import Proxy
+    else:
+        raise ValueError(f'Unknown scope: {scope}')
 
 
-async def test_actor_properly_init_with_async() -> None:
-    async with Actor:
-        assert cast('Proxy', apify._actor.Actor).__wrapped__ is not None
-        assert cast('Proxy', apify._actor.Actor).__wrapped__._is_initialized
-    assert not cast('Proxy', apify._actor.Actor).__wrapped__._is_initialized
+async def test_actor_init_instance_manual() -> None:
+    """Test that Actor instance can be properly initialized and cleaned up manually."""
+    actor = Actor()
+    await actor.init()
+    assert actor._is_initialized is True
+    await actor.exit()
+    assert actor._is_initialized is False
 
 
-async def test_actor_init() -> None:
-    my_actor = Actor()
+async def test_actor_init_instance_async_with() -> None:
+    """Test that Actor instance can be properly initialized and cleaned up using async context manager."""
+    actor = Actor()
+    async with actor:
+        assert actor._is_initialized is True
 
-    await my_actor.init()
-    assert my_actor._is_initialized is True
+    assert actor._is_initialized is False
 
-    await my_actor.exit()
-    assert my_actor._is_initialized is False
 
+async def test_actor_init_class_manual() -> None:
+    """Test that Actor class can be properly initialized and cleaned up manually."""
+    await Actor.init()
+    assert Actor._is_initialized is True
+    await Actor.exit()
+    assert not Actor._is_initialized
 
-async def test_double_init_raises_error(prepare_test_env: Callable) -> None:
+
+async def test_actor_init_class_async_with() -> None:
+    """Test that Actor class can be properly initialized and cleaned up using async context manager."""
     async with Actor:
-        assert Actor._is_initialized
-        with pytest.raises(RuntimeError):
-            await Actor.init()
+        assert Actor._is_initialized is True
 
-    prepare_test_env()
+    assert not Actor._is_initialized
 
-    async with Actor() as actor:
-        assert actor._is_initialized
-        with pytest.raises(RuntimeError):
-            await actor.init()
 
-    prepare_test_env()
+async def test_fail_properly_deinitializes_actor(actor: _ActorType) -> None:
+    """Test that fail() method properly deinitializes the Actor."""
+    assert actor._is_initialized
+    await actor.fail()
+    assert actor._is_initialized is False
 
-    async with Actor() as actor:
-        assert actor._is_initialized
-        with pytest.raises(RuntimeError):
-            await actor.init()
 
+async def test_actor_handles_exceptions_and_cleans_up_properly() -> None:
+    """Test that Actor properly cleans up when an exception occurs in the async context manager."""
+    actor = None
+
+    with contextlib.suppress(Exception):
+        async with Actor() as actor:
+            assert actor._is_initialized
+            raise Exception('Failed')  # noqa: TRY002
+
+    assert actor is not None
+    assert actor._is_initialized is False
+
+
+async def test_double_init_raises_runtime_error(actor: _ActorType) -> None:
+    """Test that attempting to initialize an already initialized Actor raises RuntimeError."""
+    assert actor._is_initialized
+    with pytest.raises(RuntimeError):
+        await actor.init()
+
+
+async def test_exit_without_init_raises_runtime_error() -> None:
+    """Test that calling exit() on an uninitialized Actor raises RuntimeError."""
+    with pytest.raises(RuntimeError):
+        await Actor.exit()
+
+    with pytest.raises(RuntimeError):
+        await Actor().exit()
+
+
+async def test_fail_without_init_raises_runtime_error() -> None:
+    """Test that calling fail() on an uninitialized Actor raises RuntimeError."""
+    with pytest.raises(RuntimeError):
+        await Actor.fail()
+
+    with pytest.raises(RuntimeError):
+        await Actor().fail()
+
+
+async def test_reboot_in_local_environment_logs_error_message(
+    actor: _ActorType,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test that reboot() logs an error when not running on the Apify platform."""
+    await actor.reboot()
+
+    # Check that the error message was logged
+    assert 'Actor.reboot() is only supported when running on the Apify platform.' in caplog.text
 
-async def test_actor_exits_cleanly_with_events(monkeypatch: pytest.MonkeyPatch) -> None:
+
+async def test_exit_sets_custom_exit_code_and_status_message(actor: _ActorType) -> None:
+    """Test that exit() properly sets custom exit code and status message."""
+    await actor.exit(exit_code=42, status_message='Exiting with code 42')
+    assert actor.exit_code == 42
+    assert actor.status_message == 'Exiting with code 42'
+
+
+async def test_fail_sets_custom_exit_code_and_status_message(actor: _ActorType) -> None:
+    """Test that fail() properly sets custom exit code and status message."""
+    await actor.fail(exit_code=99, status_message='Failing with code 99')
+    assert actor.exit_code == 99
+    assert actor.status_message == 'Failing with code 99'
+
+
+async def test_unhandled_exception_sets_error_exit_code() -> None:
+    """Test that unhandled exceptions in context manager set the error exit code."""
+    actor = Actor(exit_process=False)
+    with pytest.raises(RuntimeError):
+        async with actor:
+            raise RuntimeError('Test error')
+
+    assert actor.exit_code == ActorExitCodes.ERROR_USER_FUNCTION_THREW.value
+
+
+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')
     monkeypatch.setenv(ApifyEnvVars.PERSIST_STATE_INTERVAL_MILLIS, '100')
     on_persist = []
@@ -77,11 +198,11 @@ def on_event(event_type: Event) -> Callable:
             return lambda data: on_system_info.append(data)
         return lambda data: print(data)
 
-    my_actor = Actor()
-    async with my_actor:
-        assert my_actor._is_initialized
-        my_actor.on(Event.PERSIST_STATE, on_event(Event.PERSIST_STATE))
-        my_actor.on(Event.SYSTEM_INFO, on_event(Event.SYSTEM_INFO))
+    actor = Actor()
+    async with actor:
+        assert actor._is_initialized
+        actor.on(Event.PERSIST_STATE, on_event(Event.PERSIST_STATE))
+        actor.on(Event.SYSTEM_INFO, on_event(Event.SYSTEM_INFO))
         await asyncio.sleep(1)
 
     on_persist_count = len(on_persist)
@@ -95,43 +216,9 @@ def on_event(event_type: Event) -> Callable:
     assert on_system_info_count == len(on_system_info)
 
 
-async def test_exit_without_init_raises_error() -> None:
-    with pytest.raises(RuntimeError):
-        await Actor.exit()
-
-
-async def test_actor_fails_cleanly() -> None:
-    async with Actor() as actor:
-        assert actor._is_initialized
-        await actor.fail()
-
-    assert actor._is_initialized is False
-
-
-async def test_actor_handles_failure_gracefully() -> None:
-    my_actor = None
-
-    with contextlib.suppress(Exception):
-        async with Actor() as my_actor:
-            assert my_actor._is_initialized
-            raise Exception('Failed')  # noqa: TRY002
-
-    assert my_actor is not None
-    assert my_actor._is_initialized is False
-
-
-async def test_fail_without_init_raises_error() -> None:
-    with pytest.raises(RuntimeError):
-        await Actor.fail()
-
-
-async def test_actor_reboot_fails_locally() -> None:
-    with pytest.raises(RuntimeError):
-        await Actor.reboot()
-
-
 @pytest.mark.skipif(sys.version_info >= (3, 13), reason='Suffers flaky behavior on Python 3.13')
 async def test_actor_handles_migrating_event_correctly(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Test that Actor handles MIGRATING events correctly by emitting PERSIST_STATE."""
     # This should test whether when you get a MIGRATING event,
     # the Actor automatically emits the PERSIST_STATE event with data `{'isMigrating': True}`
     monkeypatch.setenv(ApifyEnvVars.PERSIST_STATE_INTERVAL_MILLIS, '500')