Add missing tests (#12)

Author: gabrielfeo

build.gradle.kts

@@ -110,6 +110,12 @@ publishing {
     }
 }
 
+testing {
+    suites.withType<JvmTestSuite> {
+        useKotlinTest()
+    }
+}
+
 dependencies {
     api("com.squareup.moshi:moshi:1.14.0")
     implementation("com.squareup.moshi:moshi-kotlin:1.14.0")
@@ -118,4 +124,7 @@ dependencies {
     implementation("com.squareup.retrofit2:converter-moshi:2.9.0")
     implementation("com.squareup.retrofit2:converter-scalars:2.9.0")
     api("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4")
+    testImplementation("com.squareup.okhttp3:mockwebserver:4.10.0")
+    testImplementation("com.squareup.okio:okio:3.3.0")
+    testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.6.4")
 }

…o/gradle/enterprise/api/ApiExtensions.kt …ise/api/GradleEnterpriseApiExtensions.ktsrc/main/kotlin/com/gabrielfeo/gradle/enterprise/api/ApiExtensions.kt renamed to src/main/kotlin/com/gabrielfeo/gradle/enterprise/api/GradleEnterpriseApiExtensions.kt src/main/kotlin/com/gabrielfeo/gradle/enterprise/api/ApiExtensions.kt renamed to src/main/kotlin/com/gabrielfeo/gradle/enterprise/api/GradleEnterpriseApiExtensions.kt

@@ -1,3 +1,5 @@
+@file:Suppress("unused")
+
 package com.gabrielfeo.gradle.enterprise.api
 
 import com.gabrielfeo.gradle.enterprise.api.internal.API_MAX_BUILDS
@@ -23,26 +25,30 @@ fun GradleEnterpriseApi.getBuildsFlow(
     sinceBuild: String? = null,
     fromInstant: Long? = null,
     fromBuild: String? = null,
-): Flow<Build> = flow {
-    val firstBuilds = getBuilds(
-        since = since,
-        sinceBuild = sinceBuild,
-        fromInstant = fromInstant,
-        fromBuild = fromBuild,
-        maxBuilds = API_MAX_BUILDS,
-    )
-    val pagedBuilds = firstBuilds.asFlow().pagedUntilLastBuild(maxPerRequest = API_MAX_BUILDS)
-    emitAll(pagedBuilds)
+    buildsPerPage: Int = API_MAX_BUILDS,
+): Flow<Build> {
+    val api = this
+    return flow {
+        val firstBuilds = getBuilds(
+            since = since,
+            sinceBuild = sinceBuild,
+            fromInstant = fromInstant,
+            fromBuild = fromBuild,
+            maxBuilds = buildsPerPage,
+        )
+        val pagedBuilds = firstBuilds.asFlow().pagedUntilLastBuild(api, buildsPerPage)
+        emitAll(pagedBuilds)
+    }
 }
 
 /**
  * Gets [GradleAttributes] of all builds from a given date. Queries [GradleEnterpriseApi.getBuilds]
  * first, since it's the only endpoint providing a timeline of builds, then maps each to
  * [GradleEnterpriseApi.getGradleAttributes].
  *
- * Don't expect client-side filtering to be efficient. Does as many concurrent calls
- * as it can, requesting attributes in an eager coroutine, in [scope]. For other params,
- * see [getBuildsFlow] and [GradleEnterpriseApi.getBuilds].
+ * Don't expect client-side filtering to be efficient. Will request up to [Int.MAX_VALUE]
+ * builds and their attributes concurrently and eagerly, with a buffer, in coroutines started in
+ * [scope]. For other params, see [getBuildsFlow] and [GradleEnterpriseApi.getBuilds].
  *
  * @param scope CoroutineScope in which to create coroutines. Defaults to [GlobalScope].
  */
@@ -59,6 +65,6 @@ fun GradleEnterpriseApi.getGradleAttributesFlow(
         sinceBuild = sinceBuild,
         fromInstant = fromInstant,
         fromBuild = fromBuild
-    ).withGradleAttributes(scope).map { (_, attrs) ->
+    ).withGradleAttributes(scope, api = this).map { (_, attrs) ->
         attrs
     }

src/main/kotlin/com/gabrielfeo/gradle/enterprise/api/Options.kt

@@ -1,51 +1,67 @@
-@file:Suppress("MemberVisibilityCanBePrivate")
+@file:Suppress("MemberVisibilityCanBePrivate", "unused")
 
 package com.gabrielfeo.gradle.enterprise.api
 
-import com.gabrielfeo.gradle.enterprise.api.Options.Cache.clear
-import com.gabrielfeo.gradle.enterprise.api.Options.Cache.longTermCacheUrlPattern
-import com.gabrielfeo.gradle.enterprise.api.Options.Cache.shortTermCacheUrlPattern
-import com.gabrielfeo.gradle.enterprise.api.internal.buildCache
-import com.gabrielfeo.gradle.enterprise.api.internal.requireBaseUrl
-import com.gabrielfeo.gradle.enterprise.api.internal.requireToken
+import com.gabrielfeo.gradle.enterprise.api.internal.*
 import java.io.File
 import kotlin.time.Duration.Companion.days
 
+val options = Options(env = RealEnv, keychain = RealKeychain(RealEnv))
+
 /**
  * Library configuration options. Should not be changed after accessing the [api] object for the
  * first time.
+ *
+ * Use the global [options] instance.
  */
-object Options {
+class Options internal constructor(
+    env: Env,
+    keychain: Keychain,
+) {
+
+    val gradleEnterpriseInstance = GradleEnterpriseInstanceOptions(env, keychain)
+    val concurrency = ConcurrencyOptions(env)
+    val cache = CacheOptions(env)
+    val debugging = DebuggingOptions(env)
 
     /**
      * Options about the GE instance, such as URL and API token.
+     *
+     * Access via the global [options] instance.
      */
-    object GradleEnterpriseInstance {
+    class GradleEnterpriseInstanceOptions internal constructor(
+        private val env: Env,
+        private val keychain: Keychain,
+    ) {
 
         /**
          * Provides the URL of a Gradle Enterprise API instance (without `/api`). By default, uses
          * environment variable `GRADLE_ENTERPRISE_URL`.
          */
         var url: () -> String = {
-            requireBaseUrl(envName = "GRADLE_ENTERPRISE_URL")
+            env["GRADLE_ENTERPRISE_URL"]
+                ?: error("GE instance URL is required")
         }
 
         /**
          * Provides the access token for a Gradle Enterprise API instance. By default, uses keychain entry
          * `gradle-enterprise-api-token` or environment variable `GRADLE_ENTERPRISE_URL`.
          */
         var token: () -> String = {
-            requireToken(
-                keychainName = "gradle-enterprise-api-token",
-                envName = "GRADLE_ENTERPRISE_API_TOKEN",
-            )
+            keychain["gradle-enterprise-api-token"]
+                ?: env["GRADLE_ENTERPRISE_API_TOKEN"]
+                ?: error("GE token is required")
         }
     }
 
     /**
      * Concurrency options.
+     *
+     * Access via the global [options] instance.
      */
-    object Concurrency {
+    class ConcurrencyOptions internal constructor(
+        env: Env,
+    ) {
 
         /**
          * Maximum amount of concurrent requests allowed. Further requests will be queued. By default,
@@ -54,7 +70,7 @@ object Options {
          * https://square.github.io/okhttp/4.x/okhttp/okhttp3/-dispatcher
          */
         var maxConcurrentRequests =
-            System.getenv("GRADLE_ENTERPRISE_API_MAX_CONCURRENT_REQUESTS")?.toInt()
+            env["GRADLE_ENTERPRISE_API_MAX_CONCURRENT_REQUESTS"]?.toInt()
                 ?: 15
     }
 
@@ -63,6 +79,8 @@ object Options {
      * API disallows HTTP caching, but this library forcefully enables it by overwriting
      * cache-related headers in API responses. Enable with [cacheEnabled].
      *
+     * Access via the global [options] instance.
+     *
      * Responses can be:
      *
      * - cached short-term: default max-age of 1 day
@@ -97,36 +115,38 @@ object Options {
      * endpoints such as `/api/build/{id}/gradle-attributes`. Thus, whenever the GE version
      * itself is upgraded, cache should be [clear]ed.
      */
-    object Cache {
+    class CacheOptions internal constructor(
+        env: Env,
+    ) {
 
         /**
          * Whether caching is enabled. By default, uses environment variable
          * `GRADLE_ENTERPRISE_API_CACHE_ENABLED` or `false`.
          */
         var cacheEnabled: Boolean =
-            System.getenv("GRADLE_ENTERPRISE_API_CACHE_ENABLED").toBoolean()
+            env["GRADLE_ENTERPRISE_API_CACHE_ENABLED"].toBoolean()
 
         /**
          * Clears [cacheDir] including files that weren't created by the cache.
          */
         fun clear() {
-            buildCache().delete()
+            buildCache(options).delete()
         }
 
         /**
          * HTTP cache location. By default, uses environment variable `GRADLE_ENTERPRISE_API_CACHE_DIR`
          * or the system temporary folder (`java.io.tmpdir` / gradle-enterprise-api-kotlin-cache).
          */
         var cacheDir =
-            System.getenv("GRADLE_ENTERPRISE_API_CACHE_DIR")?.let(::File)
+            env["GRADLE_ENTERPRISE_API_CACHE_DIR"]?.let(::File)
                 ?: File(System.getProperty("java.io.tmpdir"), "gradle-enterprise-api-kotlin-cache")
 
         /**
          * Max size of the HTTP cache. By default, uses environment variable
          * `GRADLE_ENTERPRISE_API_MAX_CACHE_SIZE` or ~1 GB.
          */
         var maxCacheSize =
-            System.getenv("GRADLE_ENTERPRISE_API_MAX_CACHE_SIZE")?.toLong()
+            env["GRADLE_ENTERPRISE_API_MAX_CACHE_SIZE"]?.toLong()
                 ?: 1_000_000_000L
 
         /**
@@ -139,15 +159,15 @@ object Options {
          * Use `|` to define multiple patterns in one, e.g. `.*gradle-attributes|.*test-distribution`.
          */
         var longTermCacheUrlPattern: Regex =
-            System.getenv("GRADLE_ENTERPRISE_API_LONG_TERM_CACHE_URL_PATTERN")?.toRegex()
+            env["GRADLE_ENTERPRISE_API_LONG_TERM_CACHE_URL_PATTERN"]?.toRegex()
                 ?: """.*/api/builds/[\d\w]+/(?:gradle|maven)-attributes""".toRegex()
 
         /**
          * Max age in seconds for URLs to be cached long-term (matched by [longTermCacheUrlPattern]).
          * By default, uses environment variable `GRADLE_ENTERPRISE_API_LONG_TERM_CACHE_MAX_AGE` or 1 year.
          */
         var longTermCacheMaxAge: Long =
-            System.getenv("GRADLE_ENTERPRISE_API_SHORT_TERM_CACHE_MAX_AGE")?.toLong()
+            env["GRADLE_ENTERPRISE_API_SHORT_TERM_CACHE_MAX_AGE"]?.toLong()
                 ?: 365.days.inWholeSeconds
 
         /**
@@ -159,28 +179,32 @@ object Options {
          * Use `|` to define multiple patterns in one, e.g. `.*gradle-attributes|.*test-distribution`.
          */
         var shortTermCacheUrlPattern: Regex =
-            System.getenv("GRADLE_ENTERPRISE_API_SHORT_TERM_CACHE_URL_PATTERN")?.toRegex()
+            env["GRADLE_ENTERPRISE_API_SHORT_TERM_CACHE_URL_PATTERN"]?.toRegex()
                 ?: """.*/builds(?:\?.*|\Z)""".toRegex()
 
         /**
          * Max age in seconds for URLs to be cached short-term (matched by [shortTermCacheUrlPattern]).
          * By default, uses environment variable `GRADLE_ENTERPRISE_API_SHORT_TERM_CACHE_MAX_AGE` or 1 day.
          */
         var shortTermCacheMaxAge: Long =
-            System.getenv("GRADLE_ENTERPRISE_API_SHORT_TERM_CACHE_MAX_AGE")?.toLong()
+            env["GRADLE_ENTERPRISE_API_SHORT_TERM_CACHE_MAX_AGE"]?.toLong()
                 ?: 1.days.inWholeSeconds
     }
 
     /**
      * Library debugging options.
+     *
+     * Access via the global [options] instance.
      */
-    object Debugging {
+    class DebuggingOptions internal constructor(
+        env: Env,
+    ) {
 
         /**
          * Enables debug logging from the library. All logging is output to stderr. By default, uses
          * environment variable `GRADLE_ENTERPRISE_API_DEBUG_LOGGING` or `false`.
          */
         var debugLoggingEnabled =
-            System.getenv("GRADLE_ENTERPRISE_API_DEBUG_LOGGING").toBoolean()
+            env["GRADLE_ENTERPRISE_API_DEBUG_LOGGING"].toBoolean()
     }
 }

src/main/kotlin/com/gabrielfeo/gradle/enterprise/api/internal/Authentication.kt

@@ -0,0 +1,9 @@
+package com.gabrielfeo.gradle.enterprise.api.internal
+
+interface Env {
+    operator fun get(name: String): String?
+}
+
+object RealEnv : Env {
+    override fun get(name: String): String? = System.getenv(name)
+}

src/main/kotlin/com/gabrielfeo/gradle/enterprise/api/internal/BaseUrl.kt

@@ -0,0 +1,29 @@
+package com.gabrielfeo.gradle.enterprise.api.internal
+
+import com.gabrielfeo.gradle.enterprise.api.options
+import java.util.logging.Level
+import java.util.logging.Logger
+
+interface Keychain {
+    operator fun get(entry: String): String?
+}
+
+class RealKeychain(
+    private val env: Env,
+) : Keychain {
+    override fun get(entry: String): String? {
+        val login = env["LOGNAME"]
+        val process = ProcessBuilder(
+            "security", "find-generic-password", "-w", "-a", login, "-s", entry
+        ).start()
+        val status = process.waitFor()
+        if (status == 0) {
+            return process.inputStream.bufferedReader().use {
+                it.readText().trim()
+            }
+        } else if (options.debugging.debugLoggingEnabled) {
+            Logger.getGlobal().log(Level.INFO, "Failed to get key from keychain (exit $status)")
+        }
+        return null
+    }
+}