Finalize change and add few more tests

Author: Pijukatel

docs/04_upgrading/upgrading_to_v3.md

@@ -58,26 +58,15 @@ async def main():
 - The default client for working with Apify platform based `RequestQueue` is now optimized and simplified client which has significantly lower amount of API calls, but does not support multiple consumers working on the same queue. It is cheaper and faster and is suitable for the majority of the use cases.
 - The full client is still available, but it has to be explicitly requested via `simple_request_queue=False` argument when using the `ApifyStorageClient`.
 
-**Before (v2.x):**
-
-```python
-from apify import Actor
-
-async def main():
-    async with Actor:
-        ...
-```
-
 **Now (v3.0):**
 
 ```python
-from apify import Actor
-from crawlee import service_locator
+from apify.storages import RequestQueue
 from apify.storage_clients import ApifyStorageClient
 
 async def main():
-    # Use the full-featured RequestQueue client only if you really need it.
-    service_locator.set_storage_client(ApifyStorageClient(simple_request_queue=False))
-    async with Actor:
-        ...
+    # Full client
+    rq_full = await RequestQueue.open(storage_client=ApifyStorageClient(simple_request_queue=False))
+    # Default optimized client
+    rq_simple = await RequestQueue.open(storage_client=ApifyStorageClient())
 ```

src/apify/storage_clients/_apify/_storage_client.py

@@ -11,7 +11,7 @@
 from ._request_queue_client_full import ApifyRequestQueueClientFull
 from ._request_queue_client_simple import ApifyRequestQueueClientSimple
 from ._utils import hash_api_base_url_and_token
-from apify import Configuration as ApifyConfiguration
+from apify._configuration import Configuration as ApifyConfiguration
 from apify._utils import docs_group
 
 if TYPE_CHECKING:
@@ -45,6 +45,8 @@ def __init__(self, *, simple_request_queue: bool = True) -> None:
     @override
     def get_additional_cache_key(self, configuration: CrawleeConfiguration) -> Hashable:
         if isinstance(configuration, ApifyConfiguration):
+            # Current design does not support opening exactly same queue with full and simple client at the same time,
+            # due to default and unnamed storages. Whichever client variation gets used first, wins.
             return hash_api_base_url_and_token(configuration)
 
         config_class = type(configuration)
@@ -94,7 +96,7 @@ async def create_rq_client(
         configuration = configuration or ApifyConfiguration.get_global_configuration()
         if isinstance(configuration, ApifyConfiguration):
             client: type[ApifyRequestQueueClient] = (
-                ApifyRequestQueueClientSimple if (self._simple_request_queue) else ApifyRequestQueueClientFull
+                ApifyRequestQueueClientSimple if self._simple_request_queue else ApifyRequestQueueClientFull
             )
             return await client.open(id=id, name=name, alias=alias, configuration=configuration)
 

tests/integration/conftest.py

@@ -20,14 +20,15 @@
 from ._utils import generate_unique_resource_name
 from apify import Actor
 from apify._models import ActorRun
+from apify.storage_clients import ApifyStorageClient
 from apify.storage_clients._apify._utils import AliasResolver
+from apify.storages import RequestQueue
 
 if TYPE_CHECKING:
     from collections.abc import AsyncGenerator, Awaitable, Callable, Coroutine, Iterator, Mapping
     from decimal import Decimal
 
     from apify_client.clients.resource_clients import ActorClientAsync
-    from crawlee.storages import RequestQueue
 
 _TOKEN_ENV_VAR = 'APIFY_TEST_USER_API_TOKEN'
 _API_URL_ENV_VAR = 'APIFY_INTEGRATION_TESTS_API_URL'
@@ -50,6 +51,9 @@ def prepare_test_env(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> Callabl
     """
 
     def _prepare_test_env() -> None:
+        # Reset the Actor class state.
+        apify._actor.Actor.__wrapped__.__class__._is_any_instance_initialized = False  # type: ignore[attr-defined]
+        apify._actor.Actor.__wrapped__.__class__._is_rebooting = False  # type: ignore[attr-defined]
         delattr(apify._actor.Actor, '__wrapped__')
 
         # Set the environment variable for the local storage directory to the temporary path.
@@ -103,14 +107,15 @@ def apify_client_async(apify_token: str) -> ApifyClientAsync:
     return ApifyClientAsync(apify_token, api_url=api_url)
 
 
-@pytest.fixture
-async def request_queue_force_cloud(apify_token: str, monkeypatch: pytest.MonkeyPatch) -> AsyncGenerator[RequestQueue]:
+@pytest.fixture(params=[False, True])
+async def default_request_queue_apify(
+    apify_token: str, monkeypatch: pytest.MonkeyPatch, request: pytest.FixtureRequest
+) -> AsyncGenerator[RequestQueue]:
     """Create an instance of the Apify request queue on the platform and drop it when the test is finished."""
-    request_queue_name = generate_unique_resource_name('request_queue')
     monkeypatch.setenv(ApifyEnvVars.TOKEN, apify_token)
 
     async with Actor:
-        rq = await Actor.open_request_queue(name=request_queue_name, force_cloud=True)
+        rq = await RequestQueue.open(storage_client=ApifyStorageClient(simple_request_queue=request.param))
         yield rq
         await rq.drop()
 

tests/integration/test_actor_request_queue.py

@@ -12,26 +12,29 @@
 from ._utils import generate_unique_resource_name
 from apify import Actor, Request
 from apify._models import ActorRun
+from apify.storage_clients import ApifyStorageClient
+from apify.storages import RequestQueue
 
 if TYPE_CHECKING:
     from collections.abc import AsyncGenerator
 
     from apify_client import ApifyClientAsync
-    from crawlee.storages import RequestQueue
 
     from .conftest import MakeActorFunction, RunActorFunction
 
 
-@pytest.fixture
+@pytest.fixture(params=[False, True])
 async def apify_named_rq(
-    apify_client_async: ApifyClientAsync, monkeypatch: pytest.MonkeyPatch
+    apify_client_async: ApifyClientAsync, monkeypatch: pytest.MonkeyPatch, request: pytest.FixtureRequest
 ) -> AsyncGenerator[RequestQueue]:
     assert apify_client_async.token
     monkeypatch.setenv(ApifyEnvVars.TOKEN, apify_client_async.token)
     request_queue_name = generate_unique_resource_name('request_queue')
 
     async with Actor:
-        request_queue = await Actor.open_request_queue(name=request_queue_name, force_cloud=True)
+        request_queue = await RequestQueue.open(
+            name=request_queue_name, storage_client=ApifyStorageClient(simple_request_queue=request.param)
+        )
         yield request_queue
         await request_queue.drop()