all integration tests should be more stable

Author: vdusek

tests/integration/test_actor_dataset.py

@@ -15,7 +15,10 @@
     from .conftest import ActorFactory
 
 
-async def test_push_and_verify_data_in_default_dataset(make_actor: ActorFactory) -> None:
+async def test_push_and_verify_data_in_default_dataset(
+    apify_client_async: ApifyClientAsync,
+    make_actor: ActorFactory,
+) -> None:
     desired_item_count = 100  # Also change inside main() if you're changing this
 
     async def main() -> None:
@@ -25,32 +28,48 @@ async def main() -> None:
 
     actor = await make_actor('push-data', main_func=main)
 
-    run_result = await actor.call()
+    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=300)
 
     assert run_result is not None
     assert run_result['status'] == 'SUCCEEDED'
+
     list_page = 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
 
 
-async def test_push_large_data_chunks_over_9mb(make_actor: ActorFactory) -> None:
+async def test_push_large_data_chunks_over_9mb(
+    apify_client_async: ApifyClientAsync,
+    make_actor: ActorFactory,
+) -> None:
     async def main() -> None:
         async with Actor:
             await Actor.push_data([{'str': 'x' * 10000} for _ in range(5000)])  # ~50MB
 
     actor = await make_actor('push-data-over-9mb', main_func=main)
 
-    run_result = await actor.call()
+    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=300)
 
     assert run_result is not None
     assert run_result['status'] == 'SUCCEEDED'
+
     async for item in actor.last_run().dataset().iterate_items():
         assert item['str'] == 'x' * 10000
 
 
-async def test_same_references_in_default_dataset(make_actor: ActorFactory) -> None:
+async def test_same_references_in_default_dataset(
+    apify_client_async: ApifyClientAsync,
+    make_actor: ActorFactory,
+) -> None:
     async def main() -> None:
         async with Actor:
             dataset1 = await Actor.open_dataset()
@@ -59,12 +78,20 @@ async def main() -> None:
 
     actor = await make_actor('dataset-same-ref-default', main_func=main)
 
-    run_result = await actor.call()
+    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=300)
+
     assert run_result is not None
     assert run_result['status'] == 'SUCCEEDED'
 
 
-async def test_same_references_in_named_dataset(make_actor: ActorFactory) -> None:
+async def test_same_references_in_named_dataset(
+    apify_client_async: ApifyClientAsync,
+    make_actor: ActorFactory,
+) -> None:
     dataset_name = generate_unique_resource_name('dataset')
 
     async def main() -> None:
@@ -84,12 +111,20 @@ async def main() -> None:
 
     actor = await make_actor('dataset-same-ref-named', main_func=main)
 
-    run_result = await actor.call(run_input={'datasetName': dataset_name})
+    call_result = await actor.call(run_input={'datasetName': dataset_name})
+    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=300)
+
     assert run_result is not None
     assert run_result['status'] == 'SUCCEEDED'
 
 
-async def test_force_cloud(apify_client_async: ApifyClientAsync, monkeypatch: pytest.MonkeyPatch) -> None:
+async def test_force_cloud(
+    apify_client_async: ApifyClientAsync,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
     assert apify_client_async.token is not None
     monkeypatch.setenv(ApifyEnvVars.TOKEN, apify_client_async.token)
 

tests/integration/test_actor_events.py

@@ -8,10 +8,15 @@
 from apify import Actor
 
 if TYPE_CHECKING:
+    from apify_client import ApifyClientAsync
+
     from .conftest import ActorFactory
 
 
-async def test_emit_and_capture_interval_events(make_actor: ActorFactory) -> None:
+async def test_emit_and_capture_interval_events(
+    apify_client_async: ApifyClientAsync,
+    make_actor: ActorFactory,
+) -> None:
     async def main() -> None:
         import os
         from datetime import datetime
@@ -54,10 +59,15 @@ async def log_event(data: Any) -> None:
 
     actor = await make_actor('actor-interval-events', main_func=main)
 
-    run_result = await actor.call()
+    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=300)
 
     assert run_result is not None
     assert run_result['status'] == 'SUCCEEDED'
+
     dataset_items_page = 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
@@ -69,7 +79,10 @@ async def log_event(data: Any) -> None:
     assert len(system_info_events) > 0
 
 
-async def test_event_listener_can_be_removed_successfully(make_actor: ActorFactory) -> None:
+async def test_event_listener_can_be_removed_successfully(
+    apify_client_async: ApifyClientAsync,
+    make_actor: ActorFactory,
+) -> None:
     async def main() -> None:
         import os
 
@@ -96,7 +109,11 @@ def count_event(data):  # type: ignore # noqa: ANN202, ANN001
 
     actor = await make_actor('actor-off-event', main_func=main)
 
-    run = await actor.call()
+    call_result = await actor.call()
+    assert call_result is not None
 
-    assert run is not None
-    assert run['status'] == 'SUCCEEDED'
+    run_client = apify_client_async.run(call_result['id'])
+    run_result = await run_client.wait_for_finish(wait_secs=300)
+
+    assert run_result is not None
+    assert run_result['status'] == 'SUCCEEDED'

tests/integration/test_actor_key_value_store.py

@@ -15,7 +15,10 @@
     from .conftest import ActorFactory
 
 
-async def test_same_references_in_default_kvs(make_actor: ActorFactory) -> None:
+async def test_same_references_in_default_kvs(
+    apify_client_async: ApifyClientAsync,
+    make_actor: ActorFactory,
+) -> None:
     async def main() -> None:
         async with Actor:
             kvs1 = await Actor.open_key_value_store()
@@ -24,12 +27,20 @@ async def main() -> None:
 
     actor = await make_actor('kvs-same-ref-default', main_func=main)
 
-    run_result = await actor.call()
+    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=300)
+
     assert run_result is not None
     assert run_result['status'] == 'SUCCEEDED'
 
 
-async def test_same_references_in_named_kvs(make_actor: ActorFactory) -> None:
+async def test_same_references_in_named_kvs(
+    apify_client_async: ApifyClientAsync,
+    make_actor: ActorFactory,
+) -> None:
     kvs_name = generate_unique_resource_name('key-value-store')
 
     async def main() -> None:
@@ -49,12 +60,20 @@ async def main() -> None:
 
     actor = await make_actor('kvs-same-ref-named', main_func=main)
 
-    run_result = await actor.call(run_input={'kvsName': kvs_name})
+    call_result = await actor.call(run_input={'kvsName': kvs_name})
+    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=300)
+
     assert run_result is not None
     assert run_result['status'] == 'SUCCEEDED'
 
 
-async def test_force_cloud(apify_client_async: ApifyClientAsync, monkeypatch: pytest.MonkeyPatch) -> None:
+async def test_force_cloud(
+    apify_client_async: ApifyClientAsync,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
     assert apify_client_async.token is not None
     monkeypatch.setenv(ApifyEnvVars.TOKEN, apify_client_async.token)
 
@@ -80,7 +99,10 @@ async def test_force_cloud(apify_client_async: ApifyClientAsync, monkeypatch: py
         await key_value_store_client.delete()
 
 
-async def test_set_and_get_value_in_same_run(make_actor: ActorFactory) -> None:
+async def test_set_and_get_value_in_same_run(
+    apify_client_async: ApifyClientAsync,
+    make_actor: ActorFactory,
+) -> None:
     async def main() -> None:
         async with Actor:
             await Actor.set_value('test', {'number': 123, 'string': 'a string', 'nested': {'test': 1}})
@@ -91,21 +113,35 @@ async def main() -> None:
 
     actor = await make_actor('actor-get-set-value', main_func=main)
 
-    run_result = await actor.call()
+    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=300)
+
     assert run_result is not None
     assert run_result['status'] == 'SUCCEEDED'
 
 
-async def test_set_value_in_one_run_and_get_value_in_another(make_actor: ActorFactory) -> None:
+async def test_set_value_in_one_run_and_get_value_in_another(
+    apify_client_async: ApifyClientAsync,
+    make_actor: ActorFactory,
+) -> None:
     async def main_set() -> None:
         async with Actor:
             await Actor.set_value('test', {'number': 123, 'string': 'a string', 'nested': {'test': 1}})
 
     actor_set = await make_actor('actor-set-value', main_func=main_set)
 
-    run_result_set = await actor_set.call()
+    call_result_set = await actor_set.call()
+    assert call_result_set is not None
+
+    run_client_set = apify_client_async.run(call_result_set['id'])
+    run_result_set = await run_client_set.wait_for_finish(wait_secs=300)
+
     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')
     assert test_record is not None
@@ -128,12 +164,20 @@ async def main_get() -> None:
     default_kvs_info = 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']})
+    call_result_get = await actor_get.call(run_input={'kvs-id': default_kvs_info['id']})
+    assert call_result_get is not None
+
+    run_client_get = apify_client_async.run(call_result_get['id'])
+    run_result_get = await run_client_get.wait_for_finish(wait_secs=300)
+
     assert run_result_get is not None
     assert run_result_get['status'] == 'SUCCEEDED'
 
 
-async def test_actor_get_input_from_run(make_actor: ActorFactory) -> None:
+async def test_actor_get_input_from_run(
+    apify_client_async: ApifyClientAsync,
+    make_actor: ActorFactory,
+) -> None:
     actor_source_files = {
         'INPUT_SCHEMA.json': """
             {
@@ -168,19 +212,27 @@ async def main():
     }
     actor = await make_actor('actor-get-input', source_files=actor_source_files)
 
-    run_result = await actor.call(
+    call_result = await actor.call(
         run_input={
             'number': 123,
             'string': 'a string',
             'nested': {'test': 1},
             'password': 'very secret',
         }
     )
+    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=300)
+
     assert run_result is not None
     assert run_result['status'] == 'SUCCEEDED'
 
 
-async def test_generate_public_url_for_kvs_record(make_actor: ActorFactory) -> None:
+async def test_generate_public_url_for_kvs_record(
+    apify_client_async: ApifyClientAsync,
+    make_actor: ActorFactory,
+) -> None:
     async def main() -> None:
         from typing import cast
 
@@ -198,6 +250,11 @@ async def main() -> None:
 
     actor = await make_actor('kvs-get-public-url', main_func=main)
 
-    run_result = await actor.call()
+    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=300)
+
     assert run_result is not None
     assert run_result['status'] == 'SUCCEEDED'