Fixes

Author: vdusek

tests/integration/actor/test_actor_api_helpers.py

@@ -293,9 +293,14 @@ async def main_outer() -> None:
 
     assert run_result_outer.status == 'SUCCEEDED'
 
-    await inner_actor.last_run().wait_for_finish(wait_secs=600)
-    inner_actor_last_run_dict = await inner_actor.last_run().get()
-    inner_actor_last_run = ActorRun.model_validate(inner_actor_last_run_dict)
+    inner_actor_run_client = inner_actor.last_run()
+    inner_actor_run = await inner_actor_run_client.wait_for_finish(wait_secs=600)
+
+    if inner_actor_run is None:
+        raise AssertionError('Failed to get inner actor run after aborting it.')
+
+    inner_actor_run_dict = inner_actor_run.model_dump(by_alias=True)
+    inner_actor_last_run = ActorRun.model_validate(inner_actor_run_dict)
 
     assert inner_actor_last_run.status == 'ABORTED'
 
@@ -471,8 +476,14 @@ async def main_client() -> None:
 
     assert ac_run_result.status == 'SUCCEEDED'
 
-    sa_run_result_dict = await server_actor.last_run().wait_for_finish(wait_secs=600)
-    sa_run_result = ActorRun.model_validate(sa_run_result_dict)
+    sa_run_client = server_actor.last_run()
+    sa_run_client_run = await sa_run_client.wait_for_finish(wait_secs=600)
+
+    if sa_run_client_run is None:
+        raise AssertionError('Failed to get server actor run after waiting for finish.')
+
+    sa_run_client_run_dict = sa_run_client_run.model_dump(by_alias=True)
+    sa_run_result = ActorRun.model_validate(sa_run_client_run_dict)
 
     assert sa_run_result.status == 'SUCCEEDED'
 

tests/integration/actor/test_actor_charge.py

@@ -84,7 +84,8 @@ async def test_actor_charge_basic(
     for is_last_attempt, _ in retry_counter(30):
         await asyncio.sleep(1)
 
-        updated_run = await apify_client_async.run(run.id).get()
+        run_client = apify_client_async.run(run.id)
+        updated_run = await run_client.get()
         assert updated_run is not None, 'Updated run should not be None'
 
         updated_run_dict = updated_run.model_dump(by_alias=True)
@@ -110,7 +111,8 @@ async def test_actor_charge_limit(
     for is_last_attempt, _ in retry_counter(30):
         await asyncio.sleep(1)
 
-        updated_run = await apify_client_async.run(run.id).get()
+        run_client = apify_client_async.run(run.id)
+        updated_run = await run_client.get()
         assert updated_run is not None, 'Updated run should not be None'
 
         updated_run_dict = updated_run.model_dump(by_alias=True)

tests/integration/actor/test_actor_request_queue.py

@@ -306,8 +306,15 @@ async def main() -> None:
     # Redirect logs even from the resurrected run
     streamed_log = await run_client.get_streamed_log(from_start=False)
     await run_client.resurrect()
+
     async with streamed_log:
-        run_result = ActorRun.model_validate(await run_client.wait_for_finish(wait_secs=600))
+        run = await run_client.wait_for_finish(wait_secs=600)
+
+        if run is None:
+            raise AssertionError('Failed to get resurrected run.')
+
+        run_dict = run.model_dump(by_alias=True)
+        run_result = ActorRun.model_validate(run_dict)
         assert run_result.status == 'SUCCEEDED'
 
 

tests/integration/apify_api/test_request_queue.py

@@ -8,6 +8,7 @@
 
 import pytest
 
+from apify_client._models import Data13, ProcessedRequest, UnprocessedRequest
 from apify_shared.consts import ApifyEnvVars
 from crawlee import service_locator
 from crawlee.crawlers import BasicCrawler
@@ -1168,15 +1169,15 @@ async def test_request_queue_deduplication_unprocessed_requests(
     assert stats_before is not None
     assert stats_before.write_count is not None
 
-    def return_unprocessed_requests(requests: list[dict], *_: Any, **__: Any) -> dict[str, list[dict]]:
+    def return_unprocessed_requests(requests: list[dict], *_: Any, **__: Any) -> Data13:
         """Simulate API returning unprocessed requests."""
-        return {
-            'processedRequests': [],
-            'unprocessedRequests': [
-                {'url': request['url'], 'uniqueKey': request['uniqueKey'], 'method': request['method']}
+        return Data13(
+            processed_requests=list[ProcessedRequest](),
+            unprocessed_requests=[
+                UnprocessedRequest(url=request['url'], unique_key=request['uniqueKey'], method=request['method'])
                 for request in requests
             ],
-        }
+        )
 
     with mock.patch(
         'apify_client._resource_clients.request_queue.RequestQueueClientAsync.batch_add_requests',