do it better

Author: vdusek

tests/integration/conftest.py

@@ -7,7 +7,7 @@
 import sys
 import textwrap
 from pathlib import Path
-from typing import TYPE_CHECKING, Callable, Protocol, cast
+from typing import TYPE_CHECKING, Any, Callable, Coroutine, Protocol, cast
 
 import pytest
 from filelock import FileLock
@@ -56,6 +56,53 @@ def apify_client_async() -> ApifyClientAsync:
     return ApifyClientAsync(api_token, api_url=api_url)
 
 
+class RunActorFunction(Protocol):
+    """A type for the `run_actor` fixture."""
+
+    def __call__(
+        self,
+        actor: ActorClientAsync,
+        *,
+        run_input: Any = None,
+    ) -> Coroutine[None, None, dict]:
+        """Initiate an Actor run and wait for its completion.
+
+        Args:
+            actor: Actor async client, in testing context usually created by `make_actor` fixture.
+            run_input: Optional input for the Actor run.
+
+        Returns:
+            Actor run result.
+        """
+
+
+@pytest.fixture
+async def run_actor(apify_client_async: ApifyClientAsync) -> RunActorFunction:
+    """Fixture for calling an Actor run and waiting for its completion.
+
+    This fixture returns a function that initiates an Actor run with optional run input, waits for its completion,
+    and retrieves the final result. It uses the `wait_for_finish` method with a timeout of 10 minutes.
+
+    Returns:
+        A coroutine that initiates an Actor run and waits for its completion.
+    """
+
+    async def _run_actor(actor: ActorClientAsync, *, run_input: Any = None) -> dict:
+        call_result = await actor.call(run_input=run_input)
+
+        assert isinstance(call_result, dict), 'The result of ActorClientAsync.call() is not a dictionary.'
+        assert 'id' in call_result, 'The result of ActorClientAsync.call() does not contain an ID.'
+
+        run_client = apify_client_async.run(call_result['id'])
+        run_result = await run_client.wait_for_finish(wait_secs=600)
+
+        assert isinstance(run_result, dict), 'The result of RunClientAsync.wait_for_finish() is not a dictionary.'
+        assert 'status' in run_result, 'The result of RunClientAsync.wait_for_finish() does not contain a status.'
+        return run_result
+
+    return _run_actor
+
+
 # Build the package wheel if it hasn't been built yet, and return the path to the wheel
 @pytest.fixture(scope='session')
 def sdk_wheel_path(tmp_path_factory: pytest.TempPathFactory, testrun_uid: str) -> Path:
@@ -130,7 +177,7 @@ def actor_base_source_files(sdk_wheel_path: Path) -> dict[str, str | bytes]:
 # Just a type for the make_actor result, so that we can import it in tests
 class ActorFactory(Protocol):
     def __call__(
-        self: ActorFactory,
+        self,
         actor_label: str,
         *,
         main_func: Callable | None = None,

tests/integration/test_actor_api_helpers.py

@@ -12,31 +12,25 @@
 if TYPE_CHECKING:
     from apify_client import ApifyClientAsync
 
-    from .conftest import ActorFactory
+    from .conftest import ActorFactory, RunActorFunction
 
 
 async def test_actor_reports_running_on_platform(
-    apify_client_async: ApifyClientAsync,
+    run_actor: RunActorFunction,
     make_actor: ActorFactory,
 ) -> None:
     async def main() -> None:
         async with Actor:
             assert Actor.is_at_home() is True
 
     actor = await make_actor('is-at-home', main_func=main)
+    run_result = await run_actor(actor)
 
-    call_result = await actor.call()
-    assert call_result is not None
-
-    run_client = apify_client_async.run(call_result['id'])
-    run_result = await run_client.wait_for_finish(wait_secs=600)
-
-    assert run_result is not None
     assert run_result['status'] == 'SUCCEEDED'
 
 
 async def test_actor_retrieves_env_vars(
-    apify_client_async: ApifyClientAsync,
+    run_actor: RunActorFunction,
     make_actor: ActorFactory,
 ) -> None:
     async def main() -> None:
@@ -56,19 +50,13 @@ async def main() -> None:
             assert len(env_dict.get('default_request_queue_id', '')) == 17
 
     actor = await make_actor('get-env', main_func=main)
+    run_result = await run_actor(actor)
 
-    call_result = await actor.call()
-    assert call_result is not None
-
-    run_client = apify_client_async.run(call_result['id'])
-    run_result = await run_client.wait_for_finish(wait_secs=600)
-
-    assert run_result is not None
     assert run_result['status'] == 'SUCCEEDED'
 
 
 async def test_actor_creates_new_client_instance(
-    apify_client_async: ApifyClientAsync,
+    run_actor: RunActorFunction,
     make_actor: ActorFactory,
 ) -> None:
     async def main() -> None:
@@ -86,14 +74,8 @@ async def main() -> None:
             await kv_store_client.set_record('OUTPUT', 'TESTING-OUTPUT')
 
     actor = await make_actor('new-client', main_func=main)
+    run_result = await run_actor(actor)
 
-    call_result = await actor.call()
-    assert call_result is not None
-
-    run_client = apify_client_async.run(call_result['id'])
-    run_result = await run_client.wait_for_finish(wait_secs=600)
-
-    assert run_result is not None
     assert run_result['status'] == 'SUCCEEDED'
 
     output_record = await actor.last_run().key_value_store().get_record('OUTPUT')
@@ -102,7 +84,7 @@ async def main() -> None:
 
 
 async def test_actor_sets_status_message(
-    apify_client_async: ApifyClientAsync,
+    run_actor: RunActorFunction,
     make_actor: ActorFactory,
 ) -> None:
     async def main() -> None:
@@ -111,32 +93,21 @@ async def main() -> None:
             await Actor.set_status_message('testing-status-message', **actor_input)
 
     actor = await make_actor('set-status-message', main_func=main)
+    run_result_1 = await run_actor(actor)
 
-    call_result = await actor.call()
-    assert call_result is not None
-
-    run_client = apify_client_async.run(call_result['id'])
-    run_result = await run_client.wait_for_finish(wait_secs=600)
-
-    assert run_result is not None
-    assert run_result['status'] == 'SUCCEEDED'
-    assert run_result['statusMessage'] == 'testing-status-message'
-    assert run_result['isStatusMessageTerminal'] is None
-
-    call_result_2 = await actor.call(run_input={'is_terminal': True})
-    assert call_result_2 is not None
+    assert run_result_1['status'] == 'SUCCEEDED'
+    assert run_result_1['statusMessage'] == 'testing-status-message'
+    assert run_result_1['isStatusMessageTerminal'] is None
 
-    run_client_2 = apify_client_async.run(call_result_2['id'])
-    run_result_2 = await run_client_2.wait_for_finish(wait_secs=600)
+    run_result_2 = await run_actor(actor, run_input={'is_terminal': True})
 
-    assert run_result_2 is not None
     assert run_result_2['status'] == 'SUCCEEDED'
     assert run_result_2['statusMessage'] == 'testing-status-message'
     assert run_result_2['isStatusMessageTerminal'] is True
 
 
 async def test_actor_starts_another_actor_instance(
-    apify_client_async: ApifyClientAsync,
+    run_actor: RunActorFunction,
     make_actor: ActorFactory,
 ) -> None:
     async def main_inner() -> None:
@@ -166,13 +137,11 @@ async def main_outer() -> None:
     inner_actor_id = (await inner_actor.get() or {})['id']
     test_value = crypto_random_object_id()
 
-    outer_call_result = await outer_actor.call(run_input={'test_value': test_value, 'inner_actor_id': inner_actor_id})
-    assert outer_call_result is not None
-
-    run_client_outer = apify_client_async.run(outer_call_result['id'])
-    run_result_outer = await run_client_outer.wait_for_finish(wait_secs=600)
+    run_result_outer = await run_actor(
+        outer_actor,
+        run_input={'test_value': test_value, 'inner_actor_id': inner_actor_id},
+    )
 
-    assert run_result_outer is not None
     assert run_result_outer['status'] == 'SUCCEEDED'
 
     await inner_actor.last_run().wait_for_finish(wait_secs=600)
@@ -183,7 +152,7 @@ async def main_outer() -> None:
 
 
 async def test_actor_calls_another_actor(
-    apify_client_async: ApifyClientAsync,
+    run_actor: RunActorFunction,
     make_actor: ActorFactory,
 ) -> None:
     async def main_inner() -> None:
@@ -213,13 +182,11 @@ async def main_outer() -> None:
     inner_actor_id = (await inner_actor.get() or {})['id']
     test_value = crypto_random_object_id()
 
-    outer_call_result = await outer_actor.call(run_input={'test_value': test_value, 'inner_actor_id': inner_actor_id})
-    assert outer_call_result is not None
-
-    run_client_outer = apify_client_async.run(outer_call_result['id'])
-    run_result_outer = await run_client_outer.wait_for_finish(wait_secs=600)
+    run_result_outer = await run_actor(
+        outer_actor,
+        run_input={'test_value': test_value, 'inner_actor_id': inner_actor_id},
+    )
 
-    assert run_result_outer is not None
     assert run_result_outer['status'] == 'SUCCEEDED'
 
     await inner_actor.last_run().wait_for_finish(wait_secs=600)
@@ -231,6 +198,7 @@ async def main_outer() -> None:
 
 async def test_actor_calls_task(
     apify_client_async: ApifyClientAsync,
+    run_actor: RunActorFunction,
     make_actor: ActorFactory,
 ) -> None:
     async def main_inner() -> None:
@@ -265,13 +233,11 @@ async def main_outer() -> None:
         task_input={'test_value': test_value},
     )
 
-    outer_call_result = await outer_actor.call(run_input={'test_value': test_value, 'inner_task_id': task['id']})
-    assert outer_call_result is not None
-
-    run_client_outer = apify_client_async.run(outer_call_result['id'])
-    run_result_outer = await run_client_outer.wait_for_finish(wait_secs=600)
+    run_result_outer = await run_actor(
+        outer_actor,
+        run_input={'test_value': test_value, 'inner_task_id': task['id']},
+    )
 
-    assert run_result_outer is not None
     assert run_result_outer['status'] == 'SUCCEEDED'
 
     await inner_actor.last_run().wait_for_finish(wait_secs=600)
@@ -284,7 +250,7 @@ async def main_outer() -> None:
 
 
 async def test_actor_aborts_another_actor_run(
-    apify_client_async: ApifyClientAsync,
+    run_actor: RunActorFunction,
     make_actor: ActorFactory,
 ) -> None:
     async def main_inner() -> None:
@@ -307,13 +273,11 @@ async def main_outer() -> None:
 
     inner_run_id = (await inner_actor.start())['id']
 
-    outer_call_result = await outer_actor.call(run_input={'inner_run_id': inner_run_id})
-    assert outer_call_result is not None
-
-    run_client_outer = apify_client_async.run(outer_call_result['id'])
-    run_result_outer = await run_client_outer.wait_for_finish(wait_secs=600)
+    run_result_outer = await run_actor(
+        outer_actor,
+        run_input={'inner_run_id': inner_run_id},
+    )
 
-    assert run_result_outer is not None
     assert run_result_outer['status'] == 'SUCCEEDED'
 
     await inner_actor.last_run().wait_for_finish(wait_secs=600)
@@ -326,7 +290,7 @@ async def main_outer() -> None:
 
 
 async def test_actor_metamorphs_into_another_actor(
-    apify_client_async: ApifyClientAsync,
+    run_actor: RunActorFunction,
     make_actor: ActorFactory,
 ) -> None:
     async def main_inner() -> None:
@@ -366,13 +330,11 @@ async def main_outer() -> None:
     inner_actor_id = (await inner_actor.get() or {})['id']
     test_value = crypto_random_object_id()
 
-    outer_call_result = await outer_actor.call(run_input={'test_value': test_value, 'inner_actor_id': inner_actor_id})
-    assert outer_call_result is not None
-
-    run_client_outer = apify_client_async.run(outer_call_result['id'])
-    run_result_outer = await run_client_outer.wait_for_finish(wait_secs=600)
+    run_result_outer = await run_actor(
+        outer_actor,
+        run_input={'test_value': test_value, 'inner_actor_id': inner_actor_id},
+    )
 
-    assert run_result_outer is not None
     assert run_result_outer['status'] == 'SUCCEEDED'
 
     outer_run_key_value_store = outer_actor.last_run().key_value_store()
@@ -388,7 +350,7 @@ async def main_outer() -> None:
 
 
 async def test_actor_reboots_successfully(
-    apify_client_async: ApifyClientAsync,
+    run_actor: RunActorFunction,
     make_actor: ActorFactory,
 ) -> None:
     async def main() -> None:
@@ -406,13 +368,11 @@ async def main() -> None:
 
     actor = await make_actor('actor_rebooter', main_func=main)
 
-    call_result = await actor.call(run_input={'counter_key': 'reboot_counter'})
-    assert call_result is not None
-
-    run_client = apify_client_async.run(call_result['id'])
-    run_result = await run_client.wait_for_finish(wait_secs=600)
+    run_result = await run_actor(
+        actor,
+        run_input={'counter_key': 'reboot_counter'},
+    )
 
-    assert run_result is not None
     assert run_result['status'] == 'SUCCEEDED'
 
     not_written_value = await actor.last_run().key_value_store().get_record('THIS_KEY_SHOULD_NOT_BE_WRITTEN')
@@ -424,7 +384,7 @@ async def main() -> None:
 
 
 async def test_actor_adds_webhook_and_receives_event(
-    apify_client_async: ApifyClientAsync,
+    run_actor: RunActorFunction,
     make_actor: ActorFactory,
 ) -> None:
     async def main_server() -> None:
@@ -487,13 +447,11 @@ async def main_client() -> None:
         server_actor_initialized = await server_actor.last_run().key_value_store().get_record('INITIALIZED')
         await asyncio.sleep(1)
 
-    ac_call_result = await client_actor.call(run_input={'server_actor_container_url': server_actor_container_url})
-    assert ac_call_result is not None
-
-    ac_run_client = apify_client_async.run(ac_call_result['id'])
-    ac_run_result = await ac_run_client.wait_for_finish(wait_secs=600)
+    ac_run_result = await run_actor(
+        client_actor,
+        run_input={'server_actor_container_url': server_actor_container_url},
+    )
 
-    assert ac_run_result is not None
     assert ac_run_result['status'] == 'SUCCEEDED'
 
     sa_run_result = await server_actor.last_run().wait_for_finish(wait_secs=600)

tests/unit/conftest.py

@@ -64,12 +64,12 @@ def _reset_and_patch_default_instances(
 
 # This class is used to patch the ApifyClientAsync methods to return a fixed value or be replaced with another method.
 class ApifyClientAsyncPatcher:
-    def __init__(self: ApifyClientAsyncPatcher, monkeypatch: pytest.MonkeyPatch) -> None:
+    def __init__(self, monkeypatch: pytest.MonkeyPatch) -> None:
         self.monkeypatch = monkeypatch
         self.calls: dict[str, dict[str, list[tuple[Any, Any]]]] = defaultdict(lambda: defaultdict(list))
 
     def patch(
-        self: ApifyClientAsyncPatcher,
+        self,
         method: str,
         submethod: str,
         *,