adding checks for list page size and completedTime for listInstanceIds

Author: bachuv

client/src/main/java/com/microsoft/durabletask/DurableTaskClient.java

@@ -523,9 +523,12 @@ public List<OrchestrationHistoryEvent> getOrchestrationHistory(String instanceId
      * @param runtimeStatus   optional set of runtime statuses to filter by; if {@code null}, all statuses are included
      * @param completedTimeFrom inclusive lower bound of the orchestration completed time filter
      * @param completedTimeTo   inclusive upper bound of the orchestration completed time filter
-     * @param pageSize          maximum number of instance IDs to return in a single page
+     * @param pageSize          maximum number of instance IDs to return in a single page; must be between 1 and 1000
      * @param lastInstanceKey   continuation key from the previous page; {@code null} to start from the beginning
      * @return a page of orchestration instance IDs along with a continuation token
+     * @throws IllegalArgumentException      if {@code pageSize} is outside the supported range, or if both
+     *                                       {@code completedTimeFrom} and {@code completedTimeTo} are supplied and
+     *                                       {@code completedTimeTo} is not strictly after {@code completedTimeFrom}
      * @throws UnsupportedOperationException if this client implementation does not support instance ID listing
      */
     public InstanceIdPage listInstanceIds(

client/src/main/java/com/microsoft/durabletask/DurableTaskGrpcClient.java

@@ -26,6 +26,8 @@
  */
 public final class DurableTaskGrpcClient extends DurableTaskClient {
     private static final int DEFAULT_PORT = 4001;
+    private static final int MIN_LIST_PAGE_SIZE = 1;
+    private static final int MAX_LIST_PAGE_SIZE = 1000;
     private static final Logger logger = Logger.getLogger(DurableTaskGrpcClient.class.getPackage().getName());
 
     private final DataConverter dataConverter;
@@ -454,6 +456,19 @@ public InstanceIdPage listInstanceIds(
             int pageSize,
             @Nullable String lastInstanceKey) {
 
+        // Validate defensively before making a remote call: the sidecar would otherwise have to
+        // reject malformed requests (or worse, accept Integer.MAX_VALUE and try to allocate a
+        // page of that size). Range matches the export-history limits.
+        if (pageSize < MIN_LIST_PAGE_SIZE || pageSize > MAX_LIST_PAGE_SIZE) {
+            throw new IllegalArgumentException(
+                    "pageSize must be between " + MIN_LIST_PAGE_SIZE +
+                    " and " + MAX_LIST_PAGE_SIZE + ". Got: " + pageSize);
+        }
+        if (completedTimeFrom != null && completedTimeTo != null
+                && !completedTimeTo.isAfter(completedTimeFrom)) {
+            throw new IllegalArgumentException("completedTimeTo must be after completedTimeFrom.");
+        }
+
         ListInstanceIdsRequest.Builder builder = ListInstanceIdsRequest.newBuilder()
                 .setPageSize(pageSize);
 

client/src/test/java/com/microsoft/durabletask/DurableTaskGrpcClientListInstanceIdsTest.java

@@ -0,0 +1,93 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+package com.microsoft.durabletask;
+
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.time.Instant;
+
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Unit tests for {@link DurableTaskGrpcClient#listInstanceIds} input validation.
+ *
+ * <p>Validation runs before any gRPC call, so an unconnected channel is sufficient
+ * to construct the client.
+ */
+public class DurableTaskGrpcClientListInstanceIdsTest {
+
+    private ManagedChannel channel;
+    private DurableTaskClient client;
+
+    @BeforeEach
+    void setUp() {
+        // gRPC channels connect lazily, so this never actually opens a socket as long as
+        // we never invoke an RPC.
+        this.channel = ManagedChannelBuilder.forAddress("localhost", 0)
+                .usePlaintext()
+                .build();
+        this.client = new DurableTaskGrpcClientBuilder().grpcChannel(this.channel).build();
+    }
+
+    @AfterEach
+    void tearDown() {
+        if (this.client != null) {
+            this.client.close();
+        }
+        if (this.channel != null) {
+            this.channel.shutdownNow();
+        }
+    }
+
+    @Test
+    void listInstanceIds_pageSizeZero_throwsIllegalArgumentException() {
+        IllegalArgumentException ex = assertThrows(IllegalArgumentException.class, () ->
+                this.client.listInstanceIds(null, null, null, 0, null));
+        assertTrue(ex.getMessage().contains("pageSize"));
+    }
+
+    @Test
+    void listInstanceIds_pageSizeNegative_throwsIllegalArgumentException() {
+        IllegalArgumentException ex = assertThrows(IllegalArgumentException.class, () ->
+                this.client.listInstanceIds(null, null, null, -1, null));
+        assertTrue(ex.getMessage().contains("pageSize"));
+    }
+
+    @Test
+    void listInstanceIds_pageSizeMaxInt_throwsIllegalArgumentException() {
+        IllegalArgumentException ex = assertThrows(IllegalArgumentException.class, () ->
+                this.client.listInstanceIds(null, null, null, Integer.MAX_VALUE, null));
+        assertTrue(ex.getMessage().contains("pageSize"));
+    }
+
+    @Test
+    void listInstanceIds_pageSizeAboveMax_throwsIllegalArgumentException() {
+        IllegalArgumentException ex = assertThrows(IllegalArgumentException.class, () ->
+                this.client.listInstanceIds(null, null, null, 1001, null));
+        assertTrue(ex.getMessage().contains("pageSize"));
+    }
+
+    @Test
+    void listInstanceIds_completedTimeToBeforeFrom_throwsIllegalArgumentException() {
+        Instant from = Instant.parse("2026-03-01T00:00:00Z");
+        Instant to = Instant.parse("2026-02-01T00:00:00Z");
+
+        IllegalArgumentException ex = assertThrows(IllegalArgumentException.class, () ->
+                this.client.listInstanceIds(null, from, to, 100, null));
+        assertTrue(ex.getMessage().contains("completedTimeTo"));
+    }
+
+    @Test
+    void listInstanceIds_completedTimeToEqualsFrom_throwsIllegalArgumentException() {
+        Instant ts = Instant.parse("2026-03-01T00:00:00Z");
+
+        IllegalArgumentException ex = assertThrows(IllegalArgumentException.class, () ->
+                this.client.listInstanceIds(null, ts, ts, 100, null));
+        assertTrue(ex.getMessage().contains("completedTimeTo"));
+    }
+}