Finalize

Author: Pijukatel

src/apify/storage_clients/_apify/_alias_resolving.py

@@ -233,6 +233,16 @@ async def store_mapping(self, storage_id: str) -> None:
         except Exception as exc:
             logger.warning(f'Error storing alias mapping for {self._alias}: {exc}')
 
+    @cached_property
+    def _storage_key(self) -> str:
+        return self._ALIAS_STORAGE_KEY_SEPARATOR.join(
+            [
+                self._storage_type,
+                self._alias,
+                hash_api_base_url_and_token(self._configuration),
+            ]
+        )
+
     @staticmethod
     async def _get_default_kvs_client(configuration: Configuration) -> KeyValueStoreClientAsync:
         """Get a client for the default key-value store."""
@@ -248,13 +258,3 @@ async def _get_default_kvs_client(configuration: Configuration) -> KeyValueStore
             raise ValueError("'Configuration.default_key_value_store_id' must be set.")
 
         return apify_client_async.key_value_store(key_value_store_id=configuration.default_key_value_store_id)
-
-    @cached_property
-    def _storage_key(self) -> str:
-        return self._ALIAS_STORAGE_KEY_SEPARATOR.join(
-            [
-                self._storage_type,
-                self._alias,
-                hash_api_base_url_and_token(self._configuration),
-            ]
-        )

tests/e2e/test_schema_storages/actor_source/actor.json

@@ -11,43 +11,7 @@
                     }
                 }
             },
-            "custom_d": {
-                "actorSpecification": 1,
-                "fields": {
-                    "properties": {
-                        "id": { "type": "string" }
-                    }
-                }
-            }
-        },
-        "key_value_stores": {
-            "default": {
-                "actorSpecification": 1,
-                "fields": {
-                    "properties": {
-                        "id": { "type": "string" }
-                    }
-                }
-            },
-            "custom_kvs": {
-                "actorSpecification": 1,
-                "fields": {
-                    "properties": {
-                        "id": { "type": "string" }
-                    }
-                }
-            }
-        },
-        "request_queues": {
-            "default": {
-                "actorSpecification": 1,
-                "fields": {
-                    "properties": {
-                        "id": { "type": "string" }
-                    }
-                }
-            },
-            "custom_rq": {
+            "custom": {
                 "actorSpecification": 1,
                 "fields": {
                     "properties": {

tests/e2e/test_schema_storages/actor_source/main.py

@@ -4,12 +4,4 @@
 async def main() -> None:
     async with Actor:
         assert Actor.configuration.actor_storages
-        assert (await Actor.open_dataset(alias='custom_d')).id == Actor.configuration.actor_storages.datasets[
-            'custom_d'
-        ]
-        assert (await Actor.open_dataset(alias='custom_kvs')).id == Actor.configuration.actor_storages.datasets[
-            'custom_kvs'
-        ]
-        assert (await Actor.open_dataset(alias='custom_rq')).id == Actor.configuration.actor_storages.datasets[
-            'custom_rq'
-        ]
+        assert (await Actor.open_dataset(alias='custom')).id == Actor.configuration.actor_storages.datasets['custom']

tests/unit/storage_clients/test_alias_resolver.py

@@ -78,23 +78,22 @@ async def test_get_alias_map_returns_in_memory_map() -> None:
     assert result == {}
 
 
-async def test_actor_storages_alias_resolving() -> None:
-    """Test that `AliasResolver.register_aliases` correctly updates default KVS with Actor storages."""
+async def test_configuration_storages_alias_resolving() -> None:
+    """Test that `AliasResolver` correctly resolves ids of storages registered in Configuration."""
 
     # Actor storages
     datasets = {'default': 'default_dataset_id', 'custom': 'custom_Dataset_id'}
     request_queues = {'default': 'default_request_queue_id', 'custom': 'custom_RequestQueue_id'}
     key_value_stores = {'default': 'default_key_value_store_id', 'custom': 'custom_KeyValueStore_id'}
 
-    # Set up the configuration and storage client for the test
+    # Set up the configuration with the storage mapping
     configuration = Configuration(
-        default_key_value_store_id='default_kvs_id',
         actor_storages=ActorStorages(
             datasets=datasets, request_queues=request_queues, key_value_stores=key_value_stores
         ),
     )
 
-    # Construct the expected mapping
+    # Check that id of each non-default storage saved in the mapping is resolved
     for storage_type in ('Dataset', 'KeyValueStore', 'RequestQueue'):
         assert (
             await AliasResolver(storage_type=storage_type, alias='custom', configuration=configuration).resolve_id()