Update tests acc to new version of client

Author: vdusek

pyproject.toml

@@ -44,7 +44,7 @@ dependencies = [
 dev = [
     "build ~= 1.2.0",
     "filelock ~= 3.14.0",
-    "mypy ~= 1.7.0",
+    "mypy ~= 1.10.0",
     "pre-commit ~= 3.5.0",
     "pydoc-markdown ~= 4.8.0",
     "pytest ~= 8.2.0",

tests/integration/test_actor_api_helpers.py

@@ -77,7 +77,7 @@ async def main() -> None:
         assert run_result is not None
         assert run_result['status'] == 'SUCCEEDED'
 
-        output_record = await actor.last_run().key_value_store().get_record('OUTPUT')
+        output_record = await (await actor.last_run()).key_value_store().get_record('OUTPUT')
         assert output_record is not None
         assert output_record['value'] == 'TESTING-OUTPUT'
 
@@ -125,7 +125,7 @@ async def main_outer() -> None:
 
                 await Actor.start(inner_actor_id, run_input={'test_value': test_value})
 
-                inner_run_status = await Actor.apify_client.actor(inner_actor_id).last_run().get()
+                inner_run_status = await (await Actor.apify_client.actor(inner_actor_id).last_run()).get()
                 assert inner_run_status is not None
                 assert inner_run_status.get('status') in ['READY', 'RUNNING']
 
@@ -140,9 +140,9 @@ async def main_outer() -> None:
         assert outer_run_result is not None
         assert outer_run_result['status'] == 'SUCCEEDED'
 
-        await inner_actor.last_run().wait_for_finish()
+        await (await inner_actor.last_run()).wait_for_finish()
 
-        inner_output_record = await inner_actor.last_run().key_value_store().get_record('OUTPUT')
+        inner_output_record = await (await inner_actor.last_run()).key_value_store().get_record('OUTPUT')
         assert inner_output_record is not None
         assert inner_output_record['value'] == f'{test_value}_XXX_{test_value}'
 
@@ -181,9 +181,9 @@ async def main_outer() -> None:
         assert outer_run_result is not None
         assert outer_run_result['status'] == 'SUCCEEDED'
 
-        await inner_actor.last_run().wait_for_finish()
+        await (await inner_actor.last_run()).wait_for_finish()
 
-        inner_output_record = await inner_actor.last_run().key_value_store().get_record('OUTPUT')
+        inner_output_record = await (await inner_actor.last_run()).key_value_store().get_record('OUTPUT')
         assert inner_output_record is not None
         assert inner_output_record['value'] == f'{test_value}_XXX_{test_value}'
 
@@ -231,9 +231,9 @@ async def main_outer() -> None:
         assert outer_run_result is not None
         assert outer_run_result['status'] == 'SUCCEEDED'
 
-        await inner_actor.last_run().wait_for_finish()
+        await (await inner_actor.last_run()).wait_for_finish()
 
-        inner_output_record = await inner_actor.last_run().key_value_store().get_record('OUTPUT')
+        inner_output_record = await (await inner_actor.last_run()).key_value_store().get_record('OUTPUT')
         assert inner_output_record is not None
         assert inner_output_record['value'] == f'{test_value}_XXX_{test_value}'
 
@@ -267,12 +267,12 @@ async def main_outer() -> None:
         assert outer_run_result is not None
         assert outer_run_result['status'] == 'SUCCEEDED'
 
-        await inner_actor.last_run().wait_for_finish()
-        inner_actor_last_run = await inner_actor.last_run().get()
+        await (await inner_actor.last_run()).wait_for_finish()
+        inner_actor_last_run = await (await inner_actor.last_run()).get()
         assert inner_actor_last_run is not None
         assert inner_actor_last_run['status'] == 'ABORTED'
 
-        inner_output_record = await inner_actor.last_run().key_value_store().get_record('OUTPUT')
+        inner_output_record = (await inner_actor.last_run()).key_value_store().get_record('OUTPUT')
         assert inner_output_record is None
 
 
@@ -320,7 +320,7 @@ async def main_outer() -> None:
         assert outer_run_result is not None
         assert outer_run_result['status'] == 'SUCCEEDED'
 
-        outer_run_key_value_store = outer_actor.last_run().key_value_store()
+        outer_run_key_value_store = (await outer_actor.last_run()).key_value_store()
 
         outer_output_record = await outer_run_key_value_store.get_record('OUTPUT')
         assert outer_output_record is not None
@@ -329,7 +329,7 @@ async def main_outer() -> None:
         assert await outer_run_key_value_store.get_record('RECORD_AFTER_METAMORPH_CALL') is None
 
         # After metamorph, the run still belongs to the original actor, so the inner one should have no runs
-        assert await inner_actor.last_run().get() is None
+        assert (await inner_actor.last_run()).get() is None
 
 
 class TestActorReboot:
@@ -353,10 +353,10 @@ async def main() -> None:
         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')
+        not_written_value = await (await actor.last_run()).key_value_store().get_record('THIS_KEY_SHOULD_NOT_BE_WRITTEN')
         assert not_written_value is None
 
-        reboot_counter = await actor.last_run().key_value_store().get_record('reboot_counter')
+        reboot_counter = await (await actor.last_run()).key_value_store().get_record('reboot_counter')
         assert reboot_counter is not None
         assert reboot_counter['value'] == 2
 
@@ -419,20 +419,20 @@ async def main_client() -> None:
         server_actor_container_url = server_actor_run['containerUrl']
 
         # Give the server actor some time to start running
-        server_actor_initialized = await server_actor.last_run().key_value_store().get_record('INITIALIZED')
+        server_actor_initialized = await (await server_actor.last_run()).key_value_store().get_record('INITIALIZED')
         while not server_actor_initialized:
-            server_actor_initialized = await server_actor.last_run().key_value_store().get_record('INITIALIZED')
+            server_actor_initialized = await (await server_actor.last_run()).key_value_store().get_record('INITIALIZED')
             await asyncio.sleep(1)
 
         client_actor_run_result = await client_actor.call(run_input={'server_actor_container_url': server_actor_container_url})
         assert client_actor_run_result is not None
         assert client_actor_run_result['status'] == 'SUCCEEDED'
 
-        server_actor_run_result = await server_actor.last_run().wait_for_finish()
+        server_actor_run_result = await (await server_actor.last_run()).wait_for_finish()
         assert server_actor_run_result is not None
         assert server_actor_run_result['status'] == 'SUCCEEDED'
 
-        webhook_body_record = await server_actor.last_run().key_value_store().get_record('WEBHOOK_BODY')
+        webhook_body_record = await (await server_actor.last_run()).key_value_store().get_record('WEBHOOK_BODY')
         assert webhook_body_record is not None
         assert webhook_body_record['value'] != ''
         parsed_webhook_body = json.loads(webhook_body_record['value'])

tests/integration/test_actor_dataset.py

@@ -29,7 +29,7 @@ async def main() -> None:
 
         assert run_result is not None
         assert run_result['status'] == 'SUCCEEDED'
-        list_page = await actor.last_run().dataset().list_items()
+        list_page = await (await actor.last_run()).dataset().list_items()
         assert list_page.items[0]['id'] == 0
         assert list_page.items[-1]['id'] == desired_item_count - 1
         assert len(list_page.items) == list_page.count == desired_item_count
@@ -45,7 +45,7 @@ async def main() -> None:
 
         assert run_result is not None
         assert run_result['status'] == 'SUCCEEDED'
-        async for item in actor.last_run().dataset().iterate_items():
+        async for item in (await actor.last_run()).dataset().iterate_items():
             assert item['str'] == 'x' * 10000
 
 

tests/integration/test_actor_events.py

@@ -58,7 +58,7 @@ async def log_event(data: Any) -> None:
 
         assert run_result is not None
         assert run_result['status'] == 'SUCCEEDED'
-        dataset_items_page = await actor.last_run().dataset().list_items()
+        dataset_items_page = await (await actor.last_run()).dataset().list_items()
         persist_state_events = [item for item in dataset_items_page.items if item['event_type'] == ActorEventTypes.PERSIST_STATE]
         system_info_events = [item for item in dataset_items_page.items if item['event_type'] == ActorEventTypes.SYSTEM_INFO]
         assert len(persist_state_events) > 2

tests/integration/test_actor_key_value_store.py

@@ -109,7 +109,7 @@ async def main_set() -> None:
         assert run_result_set is not None
         assert run_result_set['status'] == 'SUCCEEDED'
         # Externally check if the value is present in key-value store
-        test_record = await actor_set.last_run().key_value_store().get_record('test')
+        test_record = await (await actor_set.last_run()).key_value_store().get_record('test')
         assert test_record is not None
         test_value = test_record['value']
         assert test_value['number'] == 123
@@ -127,7 +127,7 @@ async def main_get() -> None:
                 assert value['nested']['test'] == 1
 
         actor_get = await make_actor('actor-get-value', main_func=main_get)
-        default_kvs_info = await actor_set.last_run().key_value_store().get()
+        default_kvs_info = await (await actor_set.last_run()).key_value_store().get()
         assert default_kvs_info is not None
 
         run_result_get = await actor_get.call(run_input={'kvs-id': default_kvs_info['id']})

tests/integration/test_actor_lifecycle.py

@@ -147,6 +147,6 @@ async def actor_function() -> None:
         run_with_output = await actor.call(run_input={'set_output': test_output})
         assert run_with_output is not None
         assert run_with_output['status'] == 'SUCCEEDED'
-        output = await actor.last_run().key_value_store().get_record('OUTPUT')
+        output = await (await actor.last_run()).key_value_store().get_record('OUTPUT')
         assert output is not None
         assert output['value'] == test_output

tests/integration/test_actor_log.py

@@ -55,7 +55,7 @@ async def main() -> None:
         assert run_result is not None
         assert run_result['status'] == 'FAILED'
 
-        run_log = await actor.last_run().log().get()
+        run_log = await (await actor.last_run()).log().get()
         assert run_log is not None
 
         run_log_lines = run_log.splitlines()

tests/integration/test_fixtures.py

@@ -29,7 +29,7 @@ async def main() -> None:
         assert run_result is not None
         assert run_result['status'] == 'SUCCEEDED'
 
-        output_record = await actor.last_run().key_value_store().get_record('OUTPUT')
+        output_record = await (await actor.last_run()).key_value_store().get_record('OUTPUT')
         assert output_record is not None
         assert run_result['actId'] == output_record['value']
 
@@ -49,7 +49,7 @@ async def main():
         assert run_result is not None
         assert run_result['status'] == 'SUCCEEDED'
 
-        output_record = await actor.last_run().key_value_store().get_record('OUTPUT')
+        output_record = await (await actor.last_run()).key_value_store().get_record('OUTPUT')
         assert output_record is not None
         assert output_record['value'] == expected_output
 
@@ -79,7 +79,7 @@ async def main():
         assert actor_run is not None
         assert actor_run['status'] == 'SUCCEEDED'
 
-        output_record = await actor.last_run().key_value_store().get_record('OUTPUT')
+        output_record = await (await actor.last_run()).key_value_store().get_record('OUTPUT')
         assert output_record is not None
 
         output_datetime = datetime.fromisoformat(output_record['value'])