test: Increase total test coverage and reduce E2E tests

Move 24 e2e tests that only exercise storage APIs or SDK logic to
integration tests (real API, no Actor deployment). Delete 4 e2e tests
already covered by existing unit/integration tests. Add 47 new unit
tests covering ChargingManager, SmartApifyStorageClient, AliasResolver,
ApifyEventManager, Configuration, crypto utilities, and Pydantic models.

E2E: 65 -> 37 (-43%), Integration: 40 -> 102, Unit: 127 -> 295

Co-Authored-By: Claude Opus 4.6 <[email protected]>

Author: vdusek

tests/e2e/test_actor_dataset.py

@@ -2,151 +2,12 @@
 
 from typing import TYPE_CHECKING
 
-from apify_shared.consts import ApifyEnvVars
-
-from ._utils import generate_unique_resource_name
 from apify import Actor
 
 if TYPE_CHECKING:
-    import pytest
-
-    from apify_client import ApifyClientAsync
-
     from .conftest import MakeActorFunction, RunActorFunction
 
 
-async def test_push_and_verify_data_in_default_dataset(
-    make_actor: MakeActorFunction,
-    run_actor: RunActorFunction,
-) -> None:
-    desired_item_count = 100  # Also change inside main() if you're changing this
-
-    async def main() -> None:
-        desired_item_count = 100
-        async with Actor:
-            await Actor.push_data([{'id': i} for i in range(desired_item_count)])
-
-    actor = await make_actor(label='push-data', main_func=main)
-    run_result = await run_actor(actor)
-
-    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: MakeActorFunction,
-    run_actor: RunActorFunction,
-) -> None:
-    async def main() -> None:
-        async with Actor:
-            await Actor.push_data([{'str': 'x' * 10000} for _ in range(5000)])  # ~50MB
-
-    actor = await make_actor(label='push-data-over-9mb', main_func=main)
-    run_result = await run_actor(actor)
-
-    assert run_result.status == 'SUCCEEDED'
-
-    async for item in actor.last_run().dataset().iterate_items():
-        assert item['str'] == 'x' * 10000
-
-
-async def test_dataset_iter_items(
-    make_actor: MakeActorFunction,
-    run_actor: RunActorFunction,
-) -> None:
-    async def main() -> None:
-        inserted_data = {'Something': 'something else'}
-
-        async with Actor:
-            dataset = await Actor.open_dataset()
-            await dataset.push_data(inserted_data)
-            requested_data = [item async for item in dataset.iterate_items()]
-
-            assert len(requested_data) == 1
-            assert requested_data[0] == inserted_data
-
-    actor = await make_actor(label='test_dataset_iter_items', main_func=main)
-    run_result = await run_actor(actor)
-    assert run_result.status == 'SUCCEEDED'
-
-
-async def test_same_references_in_default_dataset(
-    make_actor: MakeActorFunction,
-    run_actor: RunActorFunction,
-) -> None:
-    async def main() -> None:
-        async with Actor:
-            dataset1 = await Actor.open_dataset()
-            dataset2 = await Actor.open_dataset()
-            assert dataset1 is dataset2
-
-    actor = await make_actor(label='dataset-same-ref-default', main_func=main)
-    run_result = await run_actor(actor)
-
-    assert run_result.status == 'SUCCEEDED'
-
-
-async def test_same_references_in_named_dataset(
-    make_actor: MakeActorFunction,
-    run_actor: RunActorFunction,
-) -> None:
-    dataset_name = generate_unique_resource_name('dataset')
-
-    async def main() -> None:
-        async with Actor:
-            input_object = await Actor.get_input()
-            dataset_name = input_object['datasetName']
-            dataset_by_name_1 = await Actor.open_dataset(name=dataset_name)
-            dataset_by_name_2 = await Actor.open_dataset(name=dataset_name)
-            assert dataset_by_name_1 is dataset_by_name_2
-
-            dataset_1_metadata = await dataset_by_name_1.get_metadata()
-            dataset_by_id_1 = await Actor.open_dataset(id=dataset_1_metadata.id)
-            dataset_by_id_2 = await Actor.open_dataset(id=dataset_1_metadata.id)
-            assert dataset_by_id_1 is dataset_by_name_1
-            assert dataset_by_id_2 is dataset_by_id_1
-
-            await dataset_by_name_1.drop()
-
-    actor = await make_actor(label='dataset-same-ref-named', main_func=main)
-    run_result = await run_actor(actor, run_input={'datasetName': dataset_name})
-
-    assert run_result.status == 'SUCCEEDED'
-
-
-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)
-
-    dataset_name = generate_unique_resource_name('dataset')
-    dataset_item = {'foo': 'bar'}
-
-    async with Actor:
-        dataset = await Actor.open_dataset(name=dataset_name, force_cloud=True)
-        dataset_id = (await dataset.get_metadata()).id
-
-        await dataset.push_data(dataset_item)
-
-    dataset_client = apify_client_async.dataset(dataset_id)
-
-    try:
-        dataset_details = await dataset_client.get()
-        assert dataset_details is not None
-        assert dataset_details.get('name') == dataset_name
-
-        dataset_items = await dataset_client.list_items()
-        assert dataset_items.items == [dataset_item]
-    finally:
-        await dataset_client.delete()
-
-
 async def test_dataset_defaults(
     make_actor: MakeActorFunction,
     run_actor: RunActorFunction,

tests/e2e/test_actor_events.py

@@ -71,38 +71,3 @@ async def log_event(data: Any) -> None:
     ]
     assert len(persist_state_events) > 2
     assert len(system_info_events) > 0
-
-
-async def test_event_listener_can_be_removed_successfully(
-    make_actor: MakeActorFunction,
-    run_actor: RunActorFunction,
-) -> None:
-    async def main() -> None:
-        import os
-        from typing import Any
-
-        from apify_shared.consts import ApifyEnvVars
-        from crawlee.events._types import Event
-
-        os.environ[ApifyEnvVars.PERSIST_STATE_INTERVAL_MILLIS] = '100'
-
-        counter = 0
-
-        def count_event(data: Any) -> None:
-            nonlocal counter
-            print(data)
-            counter += 1
-
-        async with Actor:
-            Actor.on(Event.PERSIST_STATE, count_event)
-            await asyncio.sleep(0.5)
-            assert counter > 1
-            last_count = counter
-            Actor.off(Event.PERSIST_STATE, count_event)
-            await asyncio.sleep(0.5)
-            assert counter == last_count
-
-    actor = await make_actor(label='actor-off-event', main_func=main)
-    run_result = await run_actor(actor)
-
-    assert run_result.status == 'SUCCEEDED'

tests/e2e/test_actor_key_value_store.py

@@ -2,150 +2,12 @@
 
 from typing import TYPE_CHECKING
 
-from apify_shared.consts import ApifyEnvVars
-
-from ._utils import generate_unique_resource_name
 from apify import Actor
 
 if TYPE_CHECKING:
-    import pytest
-
-    from apify_client import ApifyClientAsync
-
     from .conftest import MakeActorFunction, RunActorFunction
 
 
-async def test_same_references_in_default_kvs(
-    make_actor: MakeActorFunction,
-    run_actor: RunActorFunction,
-) -> None:
-    async def main() -> None:
-        async with Actor:
-            kvs1 = await Actor.open_key_value_store()
-            kvs2 = await Actor.open_key_value_store()
-            assert kvs1 is kvs2
-
-    actor = await make_actor(label='kvs-same-ref-default', main_func=main)
-    run_result = await run_actor(actor)
-
-    assert run_result.status == 'SUCCEEDED'
-
-
-async def test_same_references_in_named_kvs(
-    make_actor: MakeActorFunction,
-    run_actor: RunActorFunction,
-) -> None:
-    kvs_name = generate_unique_resource_name('key-value-store')
-
-    async def main() -> None:
-        async with Actor:
-            input_object = await Actor.get_input()
-            kvs_name = input_object['kvsName']
-            kvs_by_name_1 = await Actor.open_key_value_store(name=kvs_name)
-            kvs_by_name_2 = await Actor.open_key_value_store(name=kvs_name)
-            assert kvs_by_name_1 is kvs_by_name_2
-
-            kvs_1_metadata = await kvs_by_name_1.get_metadata()
-            kvs_by_id_1 = await Actor.open_key_value_store(id=kvs_1_metadata.id)
-            kvs_by_id_2 = await Actor.open_key_value_store(id=kvs_1_metadata.id)
-            assert kvs_by_id_1 is kvs_by_name_1
-            assert kvs_by_id_2 is kvs_by_id_1
-
-            await kvs_by_name_1.drop()
-
-    actor = await make_actor(label='kvs-same-ref-named', main_func=main)
-    run_result = await run_actor(actor, run_input={'kvsName': kvs_name})
-
-    assert run_result.status == 'SUCCEEDED'
-
-
-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)
-
-    key_value_store_name = generate_unique_resource_name('key_value_store')
-
-    async with Actor:
-        key_value_store = await Actor.open_key_value_store(name=key_value_store_name, force_cloud=True)
-        key_value_store_id = (await key_value_store.get_metadata()).id
-
-        await key_value_store.set_value('foo', 'bar')
-
-    key_value_store_client = apify_client_async.key_value_store(key_value_store_id)
-
-    try:
-        key_value_store_details = await key_value_store_client.get()
-        assert key_value_store_details is not None
-        assert key_value_store_details.get('name') == key_value_store_name
-
-        key_value_store_record = await key_value_store_client.get_record('foo')
-        assert key_value_store_record is not None
-        assert key_value_store_record['value'] == 'bar'
-    finally:
-        await key_value_store_client.delete()
-
-
-async def test_set_and_get_value_in_same_run(
-    make_actor: MakeActorFunction,
-    run_actor: RunActorFunction,
-) -> None:
-    async def main() -> None:
-        async with Actor:
-            await Actor.set_value('test', {'number': 123, 'string': 'a string', 'nested': {'test': 1}})
-            value = await Actor.get_value('test')
-            assert value['number'] == 123
-            assert value['string'] == 'a string'
-            assert value['nested']['test'] == 1
-
-    actor = await make_actor(label='actor-get-set-value', main_func=main)
-    run_result = await run_actor(actor)
-
-    assert run_result.status == 'SUCCEEDED'
-
-
-async def test_set_value_in_one_run_and_get_value_in_another(
-    make_actor: MakeActorFunction,
-    run_actor: RunActorFunction,
-) -> 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(label='actor-set-value', main_func=main_set)
-    run_result_set = await run_actor(actor_set)
-
-    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
-    test_value = test_record['value']
-    assert test_value['number'] == 123
-    assert test_value['string'] == 'a string'
-    assert test_value['nested']['test'] == 1
-
-    async def main_get() -> None:
-        async with Actor:
-            input_object = await Actor.get_input()
-            # Access KVS of the previous 'set' run
-            kvs = await Actor.open_key_value_store(id=input_object['kvs-id'])
-            value = await kvs.get_value('test')
-            assert value['number'] == 123
-            assert value['string'] == 'a string'
-            assert value['nested']['test'] == 1
-
-    actor_get = await make_actor(label='actor-get-value', main_func=main_get)
-    default_kvs_info = await actor_set.last_run().key_value_store().get()
-    assert default_kvs_info is not None
-
-    run_result_get = await run_actor(actor_get, run_input={'kvs-id': default_kvs_info['id']})
-
-    assert run_result_get.status == 'SUCCEEDED'
-
-
 async def test_actor_get_input_from_run(
     make_actor: MakeActorFunction,
     run_actor: RunActorFunction,
@@ -197,41 +59,6 @@ async def main():
     assert run_result.status == 'SUCCEEDED'
 
 
-async def test_generate_public_url_for_kvs_record(
-    make_actor: MakeActorFunction,
-    run_actor: RunActorFunction,
-) -> None:
-    async def main() -> None:
-        from apify._crypto import create_hmac_signature
-        from apify.storage_clients._apify._models import ApifyKeyValueStoreMetadata
-
-        async with Actor:
-            public_api_url = Actor.configuration.api_public_base_url
-            default_kvs_id = Actor.configuration.default_key_value_store_id
-            record_key = 'public-record-key'
-
-            kvs = await Actor.open_key_value_store()
-            metadata = await kvs.get_metadata()
-
-            assert isinstance(metadata, ApifyKeyValueStoreMetadata)
-            assert metadata.url_signing_secret_key is not None
-
-            await kvs.set_value(record_key, {'exposedData': 'test'}, 'application/json')
-
-            record_url = await kvs.get_public_url(record_key)
-            signature = create_hmac_signature(metadata.url_signing_secret_key, record_key)
-            expected_record_url = (
-                f'{public_api_url}/v2/key-value-stores/{default_kvs_id}/records/{record_key}?signature={signature}'
-            )
-
-            assert record_url == expected_record_url
-
-    actor = await make_actor(label='kvs-get-public-url', main_func=main)
-    run_result = await run_actor(actor)
-
-    assert run_result.status == 'SUCCEEDED'
-
-
 async def test_kvs_defaults(
     make_actor: MakeActorFunction,
     run_actor: RunActorFunction,