add iterator

Author: jochen-testingbot

src/main/java/com/testingbot/testingbotrest/TestingbotREST.java

@@ -25,7 +25,10 @@
 import java.math.BigInteger;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
+import java.util.Collections;
 import java.util.HashMap;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
 import java.util.concurrent.TimeUnit;
 
 import org.apache.http.HttpEntity;
@@ -420,6 +423,79 @@ public TestingbotTestCollection getTests(int offset, int count, Map<String, Stri
         return this.apiGet(url.toString(), new TypeToken<TestingbotTestCollection>(){}.getType());
     }
 
+    /**
+     * Lazily iterates over all tests, paging through the API behind the scenes.
+     * Iteration stops when the API returns a page smaller than {@code pageSize}.
+     *
+     * <p>Each call to {@link Iterable#iterator()} starts a fresh walk from offset 0.
+     *
+     * @param pageSize the number of tests to fetch per request (must be {@code > 0})
+     * @return an {@link Iterable} that walks every test in the account
+     */
+    public Iterable<TestingbotTest> iterateTests(int pageSize) {
+        return iterateTests(pageSize, null);
+    }
+
+    /**
+     * Lazily iterates over all tests matching the given filters, paging behind the scenes.
+     *
+     * @param pageSize the number of tests to fetch per request (must be {@code > 0})
+     * @param filters optional server-side filters (may be null)
+     * @return an {@link Iterable} that walks every matching test
+     */
+    public Iterable<TestingbotTest> iterateTests(final int pageSize, final Map<String, String> filters) {
+        if (pageSize <= 0) {
+            throw new IllegalArgumentException("pageSize must be > 0");
+        }
+        return new Iterable<TestingbotTest>() {
+            @Override
+            public Iterator<TestingbotTest> iterator() {
+                return new Iterator<TestingbotTest>() {
+                    private int offset = 0;
+                    private Iterator<TestingbotTest> page = Collections.<TestingbotTest>emptyList().iterator();
+                    private boolean exhausted = false;
+
+                    private void advanceIfNeeded() {
+                        if (exhausted || page.hasNext()) {
+                            return;
+                        }
+                        TestingbotTestCollection collection = filters == null
+                                ? getTests(offset, pageSize)
+                                : getTests(offset, pageSize, filters);
+                        List<TestingbotTest> items = collection != null && collection.getData() != null
+                                ? collection.getData()
+                                : Collections.<TestingbotTest>emptyList();
+                        offset += items.size();
+                        page = items.iterator();
+                        if (items.size() < pageSize) {
+                            exhausted = true;
+                        }
+                    }
+
+                    @Override
+                    public boolean hasNext() {
+                        advanceIfNeeded();
+                        return page.hasNext();
+                    }
+
+                    @Override
+                    public TestingbotTest next() {
+                        advanceIfNeeded();
+                        if (!page.hasNext()) {
+                            throw new NoSuchElementException();
+                        }
+                        return page.next();
+                    }
+
+                    @Override
+                    public void remove() {
+                        throw new UnsupportedOperationException();
+                    }
+                };
+            }
+        };
+    }
+
     /**
      * Creates a new test on TestingBot.
      * See https://testingbot.com/support/api

src/test/java/com/testingbot/testingbotrest/TestingbotRestMockTest.java

@@ -20,9 +20,11 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
+import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.NoSuchElementException;
 
 import static org.junit.Assert.*;
 
@@ -47,6 +49,8 @@ public class TestingbotRestMockTest {
     // configurable response
     private volatile int responseStatus = 200;
     private volatile String responseBody = "{\"success\":true}";
+    private final java.util.concurrent.ConcurrentLinkedDeque<String> responseBodies = new java.util.concurrent.ConcurrentLinkedDeque<>();
+    private final java.util.List<String> requestUrls = java.util.Collections.synchronizedList(new ArrayList<String>());
 
     @Before
     public void setUp() throws IOException {
@@ -60,8 +64,13 @@ public void handle(HttpExchange ex) throws IOException {
                 lastAuth = ex.getRequestHeaders().getFirst("Authorization");
                 lastUserAgent = ex.getRequestHeaders().getFirst("User-Agent");
                 lastBody = read(ex.getRequestBody());
+                requestUrls.add(lastPath + (lastQuery != null ? "?" + lastQuery : ""));
 
-                byte[] out = responseBody == null ? new byte[0] : responseBody.getBytes(StandardCharsets.UTF_8);
+                String body = responseBodies.pollFirst();
+                if (body == null) {
+                    body = responseBody;
+                }
+                byte[] out = body == null ? new byte[0] : body.getBytes(StandardCharsets.UTF_8);
                 ex.sendResponseHeaders(responseStatus, out.length == 0 ? -1 : out.length);
                 if (out.length > 0) {
                     OutputStream os = ex.getResponseBody();
@@ -716,4 +725,70 @@ public void triggerLabSuite() {
         api.triggerLabSuite(4);
         assertRequest("POST", "/v1/labsuites/4/trigger");
     }
+
+    // ------------------------------------------------------------------ pagination iterator
+
+    private static String pageJson(int from, int count) {
+        StringBuilder sb = new StringBuilder("{\"data\":[");
+        for (int i = 0; i < count; i++) {
+            if (i > 0) {
+                sb.append(',');
+            }
+            sb.append("{\"session_id\":\"s").append(from + i).append("\"}");
+        }
+        sb.append("],\"meta\":{}}");
+        return sb.toString();
+    }
+
+    @Test
+    public void iterateTestsWalksAllPages() {
+        // 3 pages of 10, 10, 5 (last short page signals end-of-stream)
+        responseBodies.add(pageJson(0, 10));
+        responseBodies.add(pageJson(10, 10));
+        responseBodies.add(pageJson(20, 5));
+
+        int seen = 0;
+        for (TestingbotTest t : api.iterateTests(10)) {
+            Assert.assertEquals("s" + seen, t.getSessionId());
+            seen++;
+        }
+        Assert.assertEquals(25, seen);
+        Assert.assertEquals(3, requestUrls.size());
+        assertTrue(requestUrls.get(0).contains("offset=0"));
+        assertTrue(requestUrls.get(1).contains("offset=10"));
+        assertTrue(requestUrls.get(2).contains("offset=20"));
+    }
+
+    @Test
+    public void iterateTestsStopsImmediatelyOnEmptyPage() {
+        responseBodies.add("{\"data\":[],\"meta\":{}}");
+        Iterator<TestingbotTest> it = api.iterateTests(10).iterator();
+        assertFalse(it.hasNext());
+        Assert.assertEquals(1, requestUrls.size());
+        try {
+            it.next();
+            Assert.fail("expected NoSuchElementException");
+        } catch (NoSuchElementException expected) {
+        }
+    }
+
+    @Test
+    public void iterateTestsForwardsFilters() {
+        responseBodies.add(pageJson(0, 1)); // short page → stops after one request
+        Map<String, String> filters = new HashMap<>();
+        filters.put("group", "smoke");
+        int seen = 0;
+        for (TestingbotTest ignored : api.iterateTests(10, filters)) {
+            seen++;
+        }
+        Assert.assertEquals(1, seen);
+        Assert.assertEquals(1, requestUrls.size());
+        assertTrue(requestUrls.get(0).contains("group=smoke"));
+        assertTrue(requestUrls.get(0).contains("offset=0"));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void iterateTestsRejectsNonPositivePageSize() {
+        api.iterateTests(0);
+    }
 }