Consolidation test files

Author: vdusek

tests/integration/test_dataset.py

@@ -11,7 +11,7 @@
     from impit import Response
 
     from apify_client import ApifyClient, ApifyClientAsync
-    from apify_client._models import Dataset
+    from apify_client._models import Dataset, ListOfDatasets
     from apify_client._resource_clients.dataset import DatasetItemsPage
 
 import json
@@ -23,6 +23,45 @@
 from apify_client.errors import ApifyApiError
 
 
+async def test_dataset_collection_list(client: ApifyClient | ApifyClientAsync) -> None:
+    """Test listing datasets."""
+    result = await maybe_await(client.datasets().list(limit=10))
+    datasets_page = cast('ListOfDatasets', result)
+
+    assert datasets_page is not None
+    assert datasets_page.items is not None
+    assert isinstance(datasets_page.items, list)
+
+
+async def test_dataset_collection_list_pagination(client: ApifyClient | ApifyClientAsync) -> None:
+    """Test listing datasets with pagination."""
+    result = await maybe_await(client.datasets().list(limit=5, offset=0))
+    datasets_page = cast('ListOfDatasets', result)
+
+    assert datasets_page is not None
+    assert datasets_page.items is not None
+    assert isinstance(datasets_page.items, list)
+
+
+async def test_dataset_collection_get_or_create(client: ApifyClient | ApifyClientAsync) -> None:
+    """Test get_or_create for datasets."""
+    unique_name = get_random_resource_name('dataset')
+
+    # Create new dataset
+    result = await maybe_await(client.datasets().get_or_create(name=unique_name))
+    dataset = cast('Dataset', result)
+    assert dataset is not None
+    assert dataset.name == unique_name
+
+    # Get same dataset again (should return existing)
+    result2 = await maybe_await(client.datasets().get_or_create(name=unique_name))
+    same_dataset = cast('Dataset', result2)
+    assert same_dataset.id == dataset.id
+
+    # Cleanup
+    await maybe_await(client.dataset(dataset.id).delete())
+
+
 async def test_dataset_should_create_public_items_expiring_url_with_params(
     client: ApifyClient | ApifyClientAsync,
 ) -> None:

tests/integration/test_dataset_collection.py

@@ -6,7 +6,7 @@
 
 if TYPE_CHECKING:
     from apify_client import ApifyClient, ApifyClientAsync
-    from apify_client._models import KeyValueStore, ListOfKeys
+    from apify_client._models import KeyValueStore, ListOfKeys, ListOfKeyValueStores
 
 import json
 
@@ -17,6 +17,45 @@
 from apify_client.errors import ApifyApiError
 
 
+async def test_key_value_store_collection_list(client: ApifyClient | ApifyClientAsync) -> None:
+    """Test listing key-value stores."""
+    result = await maybe_await(client.key_value_stores().list(limit=10))
+    kvs_page = cast('ListOfKeyValueStores', result)
+
+    assert kvs_page is not None
+    assert kvs_page.items is not None
+    assert isinstance(kvs_page.items, list)
+
+
+async def test_key_value_store_collection_list_pagination(client: ApifyClient | ApifyClientAsync) -> None:
+    """Test listing key-value stores with pagination."""
+    result = await maybe_await(client.key_value_stores().list(limit=5, offset=0))
+    kvs_page = cast('ListOfKeyValueStores', result)
+
+    assert kvs_page is not None
+    assert kvs_page.items is not None
+    assert isinstance(kvs_page.items, list)
+
+
+async def test_key_value_store_collection_get_or_create(client: ApifyClient | ApifyClientAsync) -> None:
+    """Test get_or_create for key-value stores."""
+    unique_name = get_random_resource_name('kvs')
+
+    # Create new KVS
+    result = await maybe_await(client.key_value_stores().get_or_create(name=unique_name))
+    kvs = cast('KeyValueStore', result)
+    assert kvs is not None
+    assert kvs.name == unique_name
+
+    # Get same KVS again (should return existing)
+    result2 = await maybe_await(client.key_value_stores().get_or_create(name=unique_name))
+    same_kvs = cast('KeyValueStore', result2)
+    assert same_kvs.id == kvs.id
+
+    # Cleanup
+    await maybe_await(client.key_value_store(kvs.id).delete())
+
+
 async def test_key_value_store_should_create_expiring_keys_public_url_with_params(
     client: ApifyClient | ApifyClientAsync,
 ) -> None:

tests/integration/test_key_value_store.py

@@ -9,6 +9,7 @@
     from apify_client._models import (
         BatchAddResult,
         BatchDeleteResult,
+        ListOfRequestQueues,
         ListOfRequests,
         LockedRequestQueueHead,
         Request,
@@ -23,6 +24,45 @@
 from .conftest import get_random_resource_name, get_random_string, maybe_await, maybe_sleep
 
 
+async def test_request_queue_collection_list(client: ApifyClient | ApifyClientAsync) -> None:
+    """Test listing request queues."""
+    result = await maybe_await(client.request_queues().list(limit=10))
+    rq_page = cast('ListOfRequestQueues', result)
+
+    assert rq_page is not None
+    assert rq_page.items is not None
+    assert isinstance(rq_page.items, list)
+
+
+async def test_request_queue_collection_list_pagination(client: ApifyClient | ApifyClientAsync) -> None:
+    """Test listing request queues with pagination."""
+    result = await maybe_await(client.request_queues().list(limit=5, offset=0))
+    rq_page = cast('ListOfRequestQueues', result)
+
+    assert rq_page is not None
+    assert rq_page.items is not None
+    assert isinstance(rq_page.items, list)
+
+
+async def test_request_queue_collection_get_or_create(client: ApifyClient | ApifyClientAsync) -> None:
+    """Test get_or_create for request queues."""
+    unique_name = get_random_resource_name('rq')
+
+    # Create new RQ
+    result = await maybe_await(client.request_queues().get_or_create(name=unique_name))
+    rq = cast('RequestQueue', result)
+    assert rq is not None
+    assert rq.name == unique_name
+
+    # Get same RQ again (should return existing)
+    result2 = await maybe_await(client.request_queues().get_or_create(name=unique_name))
+    same_rq = cast('RequestQueue', result2)
+    assert same_rq.id == rq.id
+
+    # Cleanup
+    await maybe_await(client.request_queue(rq.id).delete())
+
+
 async def test_request_queue_lock(client: ApifyClient | ApifyClientAsync) -> None:
     result = await maybe_await(client.request_queues().get_or_create(name=get_random_resource_name('queue')))
     created_rq = cast('RequestQueue', result)