test: stop test_actor_charge_limit from hanging on a late platform abort (#1203)

`test_actor_charge_limit` failed on master
([run](https://github.com/apify/apify-sdk-python/actions/runs/39613335682/job/119267706151))
with `TIMED-OUT` where it expected `ABORTED`. The SDK charged the
expected 3 events, but the platform never aborted the run. A background
daemon enforces `max_total_charge_usd`, and it usually aborts within
seconds. This time it didn't, and the test Actor waited on
`asyncio.Event().wait()` with no end, so the run sat until its 600 s
timeout.

The Actor now waits up to 60 s for the abort and then exits on its own.
The test accepts `ABORTED` or `SUCCEEDED`, as `test_ppe_spider` already
does, and still asserts the SDK side: `charged_event_counts ==
{'foobar': 3}`. When the daemon is on time, the run still ends as
`ABORTED`.

*✍️ Drafted by Claude Code*

Author: vdusek

tests/e2e/test_actor_charge.py

@@ -87,11 +87,11 @@ async def main() -> None:
             )
             Actor.log.info('Charged', extra=asdict(charge_result))
 
-            # When the charge limit is reached, the platform auto-aborts this run. That abort races with the
-            # Actor's own clean exit, making the terminal status non-deterministic (SUCCEEDED or ABORTED). Block
-            # here so the abort always wins and the run ends deterministically as ABORTED.
+            # When the charge limit is reached, the platform auto-aborts this run. A background daemon enforces the
+            # limit, usually within seconds but sometimes far later. Give the abort time to arrive, but exit on our
+            # own afterwards, so a slow daemon can't hold the run until its timeout.
             if charge_result.event_charge_limit_reached:
-                await asyncio.Event().wait()
+                await asyncio.sleep(60)
 
     actor_client = await make_actor('ppe', main_func=main)
 
@@ -156,17 +156,18 @@ async def test_actor_charge_limit(
     run = await run_actor(ppe_actor, max_total_charge_usd=Decimal('0.2'))
 
     # The Actor charges 4 events and the budget covers 2, so the SDK charges 3 - one over the budget, which makes
-    # the platform auto-abort the run. The Actor blocks after hitting the limit (see `ppe_actor_build`) so the abort
-    # always wins the race against its clean exit, hence ABORTED. Refetch until the charged event counts propagate
-    # on the platform.
+    # the platform auto-abort the run. The Actor waits for the abort (see `ppe_actor_build`), so the run usually
+    # ends as ABORTED, or as SUCCEEDED when the platform enforces the limit late.
+    assert run.status in ('ABORTED', 'SUCCEEDED')
+
+    # Refetch until the charged event counts propagate on the platform.
     run = await poll_until_condition(
         partial(_get_run, apify_client_async, run.id),
-        lambda r: r.status == 'ABORTED' and r.charged_event_counts == {'foobar': 3},
+        lambda r: r.charged_event_counts == {'foobar': 3},
         timeout=30,
         poll_interval=1,
     )
 
-    assert run.status == 'ABORTED'
     assert run.charged_event_counts == {'foobar': 3}