Fix builds paging when models param is used

library/build.gradle.kts

@@ -227,6 +227,10 @@ tasks.named("check") {
     dependsOn("integrationTest")
 }
 
+tasks.named<Test>("integrationTest") {
+    jvmArgs("-Xmx512m")
+}
+
 java {
     consistentResolution {
         useRuntimeClasspathVersions()

library/src/integrationTest/kotlin/com/gabrielfeo/gradle/enterprise/api/extension/BuildsApiExtensionsIntegrationTest.kt

@@ -2,32 +2,86 @@ package com.gabrielfeo.gradle.enterprise.api.extension
 
 import com.gabrielfeo.gradle.enterprise.api.*
 import com.gabrielfeo.gradle.enterprise.api.internal.*
+import com.gabrielfeo.gradle.enterprise.api.model.BuildModelName
 import kotlinx.coroutines.flow.collect
 import kotlinx.coroutines.flow.take
 import kotlinx.coroutines.test.runTest
+import okhttp3.Request
 import org.junit.jupiter.api.*
 import org.junit.jupiter.api.Assertions.*
+import kotlin.test.AfterTest
+import kotlin.time.Duration.Companion.minutes
 
 class BuildsApiExtensionsIntegrationTest {
 
-    @Test
-    fun getBuildsFlowUsesQueryInAllRequests() = runTest {
+    init {
         env = RealEnv
         keychain = RealKeychain(RealSystemProperties)
-        val recorder = RequestRecorder()
-        val api = buildApi(recorder)
-        api.buildsApi.getBuildsFlow(since = 0, query = "user:*").take(2000).collect()
-        recorder.requests.forEachIndexed { i, request ->
-            assertEquals("user:*", request.url.queryParameter("query"), "[$i]")
-        }
+    }
+
+    private val recorder = RequestRecorder()
+    private val api = buildApi(recorder)
+
+    @AfterTest
+    fun setup() {
         api.shutdown()
     }
 
+    @Test
+    fun getBuildsFlowPreservesParamsAcrossRequests() = runTest(timeout = 3.minutes) {
+        api.buildsApi.getBuildsFlow(
+            since = 0,
+            query = "user:*",
+            models = listOf(BuildModelName.gradleAttributes),
+            reverse = true,
+        ).take(2000).collect()
+        recorder.requests.forEach {
+            assertUrlParam(it, "query", "user:*")
+            assertUrlParam(it, "models", "gradle-attributes")
+            assertUrlParam(it, "reverse", "true")
+        }
+    }
+
+    @Test
+    fun getBuildsFlowReplacesSinceForFromBuildAfterFirstRequest() = runTest {
+        api.buildsApi.getBuildsFlow(since = 1).take(2000).collect()
+        assertReplacedForFromBuildAfterFirstRequest(param = "since" to "1")
+    }
+
+    @Test
+    fun getBuildsFlowReplacesFromInstantForFromBuildAfterFirstRequest() = runTest {
+        api.buildsApi.getBuildsFlow(fromInstant = 1).take(2000).collect()
+        assertReplacedForFromBuildAfterFirstRequest(param = "fromInstant" to "1")
+    }
+
+    private fun assertReplacedForFromBuildAfterFirstRequest(param: Pair<String, String>) {
+        with(recorder.requests) {
+            val (key, value) = param
+            first().let {
+                assertUrlParam(it, key, value)
+                assertUrlParam(it, "fromBuild", null)
+            }
+            (this - first()).forEach {
+                assertUrlParam(it, key, null)
+                assertUrlParamNotNull(it, "fromBuild")
+            }
+        }
+    }
+
     private fun buildApi(recorder: RequestRecorder) =
         GradleEnterpriseApi.newInstance(
             config = Config(
                 clientBuilder = recorder.clientBuilder(),
                 cacheConfig = Config.CacheConfig(cacheEnabled = false),
             )
         )
+
+    private fun assertUrlParam(request: Request, key: String, expected: String?) {
+        val actual = request.url.queryParameter(key)
+        assertEquals(expected, actual, "Expected '$key='$expected', but was '$key=$actual' (${request.url})")
+    }
+
+    private fun assertUrlParamNotNull(request: Request, key: String) {
+        assertNotNull(request.url.queryParameter(key), "Expected param $key, but was null (${request.url})")
+    }
 }

library/src/main/kotlin/com/gabrielfeo/gradle/enterprise/api/extension/BuildsApiExtensions.kt

@@ -54,6 +54,7 @@ fun BuildsApi.getBuildsFlow(
                 reverse = reverse,
                 maxWaitSecs = maxWaitSecs,
                 maxBuilds = buildsPerPage,
+                models = models,
             )
             emitAll(builds.asFlow())
         }