fix: address review feedback on batch_add_requests rework

- Correct dedup_key's doc comment: the API's keyless fallback dedups by
  the raw url, not a "normalized" one.
- batch_add_requests now rejects an empty requests slice with
  InvalidArgument, matching batch_delete_requests and the reference
  client (both validate non-empty input).
- Use the imported UnprocessedRequest name instead of the fully-qualified
  crate::models:: path in the retry loop's fail-safe return.
- Replace a vacuous assert!(limit >= 0) in the lock-lifecycle test with a
  real invariant: filtering on both locked+pending must match the
  unfiltered listing.

Author: claude

CHANGELOG.md

@@ -19,6 +19,10 @@ to [Semantic Versioning](https://semver.org/).
   (was `serde_json::Value`), and rejects more than 25 requests per call with
   `ApifyClientError::InvalidArgument` instead of forwarding an oversized payload to the API
   (matching the reference client, which validates rather than auto-chunks deletes). **Breaking.**
+- `RequestQueueClient::batch_add_requests` now also rejects an empty `requests` with
+  `ApifyClientError::InvalidArgument` (was `Ok` with an empty result), matching
+  `batch_delete_requests` and the reference client, which validates both as non-empty.
+  **Breaking.**
 - `RequestQueueClient::list_and_lock_head` now returns the typed `LockedRequestQueueHead` (was
   `serde_json::Value`). **Breaking.**
 - `RequestQueueClient::list_requests` now returns the typed `RequestQueueRequestsPage` (was

src/clients/request_queue.rs

@@ -68,7 +68,7 @@ pub struct BatchAddRequestsOptions {
 
 /// Returns the key used to correlate a request across the batch-add retry loop: its explicit
 /// `unique_key` if set, otherwise its `url` — matching the API's own fallback (a request added
-/// without a `unique_key` is deduplicated by its normalized URL).
+/// without a `unique_key` is deduplicated by its raw `url`).
 fn dedup_key(request: &RequestQueueRequest) -> &str {
     request.unique_key.as_deref().unwrap_or(&request.url)
 }
@@ -327,15 +327,20 @@ impl RequestQueueClient {
     /// Unlike most methods here, this does not propagate per-chunk API errors: a chunk that fails
     /// even after retries has its requests reported in the result's `unprocessed_requests`
     /// instead, so a batch add of many requests never fails outright over one bad chunk (matching
-    /// the reference client). A [`ApifyClientError::InvalidArgument`] is still returned before any
-    /// request is sent if a single request's JSON is too large to ever fit in a chunk.
+    /// the reference client). It still returns [`ApifyClientError::InvalidArgument`] up front,
+    /// before any request is sent, for an empty `requests` (matching
+    /// [`batch_delete_requests`](Self::batch_delete_requests) and the reference client, which
+    /// validates both as non-empty) or if a single request's JSON is too large to ever fit in a
+    /// chunk.
     pub async fn batch_add_requests(
         &self,
         requests: &[RequestQueueRequest],
         options: BatchAddRequestsOptions,
     ) -> ApifyClientResult<BatchRequestsOperationResult> {
         if requests.is_empty() {
-            return Ok(BatchRequestsOperationResult::default());
+            return Err(ApifyClientError::InvalidArgument(
+                "RequestQueueClient::batch_add_requests requires at least 1 request".to_string(),
+            ));
         }
         let max_parallel = options
             .max_parallel
@@ -448,7 +453,7 @@ impl RequestQueueClient {
             processed_requests: processed,
             unprocessed_requests: remaining
                 .iter()
-                .map(|r| crate::models::UnprocessedRequest {
+                .map(|r| UnprocessedRequest {
                     unique_key: dedup_key(r).to_string(),
                     url: r.url.clone(),
                     method: r.method.clone(),

tests/request_queue.rs

@@ -360,9 +360,14 @@ async fn request_queue_lock_lifecycle() {
         })
         .await
         .expect("list requests with filter");
-    // The filter may legitimately exclude every request; the call succeeding (no parse/API
-    // error) is what this test exercises.
-    assert!(filtered.limit >= 0);
+    // The single request we added is either `locked` or `pending` (every request is one or the
+    // other), so filtering on both states must return exactly the same set as the unfiltered
+    // listing above — a real invariant, not just "the call didn't error".
+    assert_eq!(
+        filtered.items.len(),
+        listed.items.len(),
+        "filtering on both locked and pending must match the unfiltered listing"
+    );
 
     // Lazily paginate requests; we added one, so at least one should be yielded.
     let mut iter = queue_client.paginate_requests(Some(10));