Rename Options to Config (#68)

gabrielfeo · web-flow · commit 5e48330d1391 · 2023-05-22T22:35:44.000+01:00
diff --git a/examples/example-project/app/src/main/kotlin/com/gabrielfeo/gradle/enterprise/api/example/Main.kt b/examples/example-project/app/src/main/kotlin/com/gabrielfeo/gradle/enterprise/api/example/Main.kt
@@ -1,5 +1,6 @@
 package com.gabrielfeo.gradle.enterprise.api.example
 
+import com.gabrielfeo.gradle.enterprise.api.Config
 import com.gabrielfeo.gradle.enterprise.api.GradleEnterpriseApi
 import com.gabrielfeo.gradle.enterprise.api.example.analysis.mostFrequentBuilds
 import okhttp3.OkHttpClient
@@ -13,10 +14,10 @@ import okhttp3.OkHttpClient
 val clientBuilder = OkHttpClient.Builder()
 
 suspend fun main() {
-    val newOptions = GradleEnterpriseApi.options.copy(
+    val newConfig = Config(
         clientBuilder = clientBuilder,
     )
-    val gradleEnterpriseApi = GradleEnterpriseApi.newInstance(newOptions)
+    val gradleEnterpriseApi = GradleEnterpriseApi.newInstance(newConfig)
     runAllAnalysis(gradleEnterpriseApi)
     gradleEnterpriseApi.shutdown()
 }
diff --git a/library/src/main/kotlin/com/gabrielfeo/gradle/enterprise/api/Config.kt b/library/src/main/kotlin/com/gabrielfeo/gradle/enterprise/api/Config.kt
@@ -11,7 +11,7 @@ import kotlin.time.Duration.Companion.days
  * Library configuration options.
  */
 @Suppress("MemberVisibilityCanBePrivate", "unused")
-data class Options(
+data class Config(
 
     /**
      * Enables debug logging from the library. All logging is output to stderr. By default, uses
@@ -70,10 +70,10 @@ data class Options(
             ?: 60_000L,
 
     /**
-     * See [CacheOptions].
+     * See [CacheConfig].
      */
-    val cacheOptions: CacheOptions =
-        CacheOptions(),
+    val cacheConfig: CacheConfig =
+        CacheConfig(),
 ) {
 
     /**
@@ -118,7 +118,7 @@ data class Options(
      * itself is upgraded, cache should be [clear]ed.
      */
     @Suppress("MemberVisibilityCanBePrivate")
-    data class CacheOptions(
+    data class CacheConfig(
 
         /**
          * Whether caching is enabled. By default, uses environment variable
diff --git a/library/src/main/kotlin/com/gabrielfeo/gradle/enterprise/api/GradleEnterpriseApi.kt b/library/src/main/kotlin/com/gabrielfeo/gradle/enterprise/api/GradleEnterpriseApi.kt
@@ -22,7 +22,7 @@ import retrofit2.create
  * GradleEnterpriseApi.buildsApi.getBuilds(...)
  * ```
  *
- * However, if you need to change [options] at runtime or own the instance's lifecycle (e.g.
+ * However, if you need to change [config] at runtime or own the instance's lifecycle (e.g.
  * with an IoC container like Dagger), create a new instance:
  *
  * ```kotlin
@@ -41,7 +41,7 @@ interface GradleEnterpriseApi {
     /**
      * Library configuration options.
      */
-    val options: Options
+    val config: Config
 
     /**
      * Release resources allowing the program to finish before the internal client's idle timeout.
@@ -57,24 +57,24 @@ interface GradleEnterpriseApi {
         /**
          * Create a new instance of `GradleEnterpriseApi` with new options.
          */
-        fun newInstance(options: Options): GradleEnterpriseApi {
-            return RealGradleEnterpriseApi(options)
+        fun newInstance(config: Config): GradleEnterpriseApi {
+            return RealGradleEnterpriseApi(config)
         }
     }
 
 }
 
 private class RealGradleEnterpriseApi(
-    override val options: Options = Options(),
+    override val config: Config = Config(),
 ) : GradleEnterpriseApi {
 
     private val okHttpClient by lazy {
-        buildOkHttpClient(options = options)
+        buildOkHttpClient(config = config)
     }
 
     private val retrofit: Retrofit by lazy {
         buildRetrofit(
-            options,
+            config,
             okHttpClient,
             Serializer.moshi,
         )
diff --git a/library/src/main/kotlin/com/gabrielfeo/gradle/enterprise/api/internal/OkHttpClient.kt b/library/src/main/kotlin/com/gabrielfeo/gradle/enterprise/api/internal/OkHttpClient.kt
@@ -1,6 +1,6 @@
 package com.gabrielfeo.gradle.enterprise.api.internal
 
-import com.gabrielfeo.gradle.enterprise.api.Options
+import com.gabrielfeo.gradle.enterprise.api.Config
 import com.gabrielfeo.gradle.enterprise.api.internal.auth.HttpBearerAuth
 import com.gabrielfeo.gradle.enterprise.api.internal.caching.CacheEnforcingInterceptor
 import com.gabrielfeo.gradle.enterprise.api.internal.caching.CacheHitLoggingInterceptor
@@ -13,55 +13,55 @@ import java.util.logging.Level
 import java.util.logging.Logger
 
 internal fun buildOkHttpClient(
-    options: Options,
-) = with(options.clientBuilder) {
-    readTimeout(Duration.ofMillis(options.readTimeoutMillis))
-    if (options.cacheOptions.cacheEnabled) {
-        cache(buildCache(options))
+    config: Config,
+) = with(config.clientBuilder) {
+    readTimeout(Duration.ofMillis(config.readTimeoutMillis))
+    if (config.cacheConfig.cacheEnabled) {
+        cache(buildCache(config))
     }
-    addInterceptors(options)
-    addNetworkInterceptors(options)
+    addInterceptors(config)
+    addNetworkInterceptors(config)
     build().apply {
-        options.maxConcurrentRequests?.let {
+        config.maxConcurrentRequests?.let {
             dispatcher.maxRequests = it
             dispatcher.maxRequestsPerHost = it
         }
     }
 }
 
-private fun OkHttpClient.Builder.addInterceptors(options: Options) {
-    if (options.debugLoggingEnabled && options.cacheOptions.cacheEnabled) {
+private fun OkHttpClient.Builder.addInterceptors(config: Config) {
+    if (config.debugLoggingEnabled && config.cacheConfig.cacheEnabled) {
         addInterceptor(CacheHitLoggingInterceptor())
     }
 }
 
-private fun OkHttpClient.Builder.addNetworkInterceptors(options: Options) {
-    if (options.cacheOptions.cacheEnabled) {
-        addNetworkInterceptor(buildCacheEnforcingInterceptor(options))
+private fun OkHttpClient.Builder.addNetworkInterceptors(config: Config) {
+    if (config.cacheConfig.cacheEnabled) {
+        addNetworkInterceptor(buildCacheEnforcingInterceptor(config))
     }
-    if (options.debugLoggingEnabled) {
+    if (config.debugLoggingEnabled) {
         addNetworkInterceptor(HttpLoggingInterceptor().apply { level = BODY })
     }
-    addNetworkInterceptor(HttpBearerAuth("bearer", options.apiToken()))
+    addNetworkInterceptor(HttpBearerAuth("bearer", config.apiToken()))
 }
 
 internal fun buildCache(
-    options: Options
+    config: Config
 ): Cache {
-    val cacheDir = options.cacheOptions.cacheDir
-    val maxSize = options.cacheOptions.maxCacheSize
-    if (options.debugLoggingEnabled) {
+    val cacheDir = config.cacheConfig.cacheDir
+    val maxSize = config.cacheConfig.maxCacheSize
+    if (config.debugLoggingEnabled) {
         val logger = Logger.getGlobal()
         logger.log(Level.INFO, "HTTP cache dir: $cacheDir (max ${maxSize}B)")
     }
     return Cache(cacheDir, maxSize)
 }
 
 private fun buildCacheEnforcingInterceptor(
-    options: Options,
+    config: Config,
 ) = CacheEnforcingInterceptor(
-    longTermCacheUrlPattern = options.cacheOptions.longTermCacheUrlPattern,
-    longTermCacheMaxAge = options.cacheOptions.longTermCacheMaxAge,
-    shortTermCacheUrlPattern = options.cacheOptions.shortTermCacheUrlPattern,
-    shortTermCacheMaxAge = options.cacheOptions.shortTermCacheMaxAge,
+    longTermCacheUrlPattern = config.cacheConfig.longTermCacheUrlPattern,
+    longTermCacheMaxAge = config.cacheConfig.longTermCacheMaxAge,
+    shortTermCacheUrlPattern = config.cacheConfig.shortTermCacheUrlPattern,
+    shortTermCacheMaxAge = config.cacheConfig.shortTermCacheMaxAge,
 )
diff --git a/library/src/main/kotlin/com/gabrielfeo/gradle/enterprise/api/internal/Retrofit.kt b/library/src/main/kotlin/com/gabrielfeo/gradle/enterprise/api/internal/Retrofit.kt
@@ -1,18 +1,18 @@
 package com.gabrielfeo.gradle.enterprise.api.internal
 
-import com.gabrielfeo.gradle.enterprise.api.Options
+import com.gabrielfeo.gradle.enterprise.api.Config
 import com.squareup.moshi.Moshi
 import okhttp3.OkHttpClient
 import retrofit2.Retrofit
 import retrofit2.converter.moshi.MoshiConverterFactory
 import retrofit2.converter.scalars.ScalarsConverterFactory
 
 internal fun buildRetrofit(
-    options: Options,
+    config: Config,
     client: OkHttpClient,
     moshi: Moshi,
 ) = with(Retrofit.Builder()) {
-    val url = options.apiUrl
+    val url = config.apiUrl
     check("/api/" in url) { "A valid API URL must end in /api/" }
     val instanceUrl = url.substringBefore("api/")
     baseUrl(instanceUrl)
diff --git a/library/src/test/kotlin/com/gabrielfeo/gradle/enterprise/api/CacheConfigTest.kt b/library/src/test/kotlin/com/gabrielfeo/gradle/enterprise/api/CacheConfigTest.kt
@@ -1,10 +1,9 @@
 package com.gabrielfeo.gradle.enterprise.api
 
 import com.gabrielfeo.gradle.enterprise.api.internal.*
-import org.junit.jupiter.api.assertDoesNotThrow
 import kotlin.test.*
 
-class CacheOptionsTest {
+class CacheConfigTest {
 
     @BeforeTest
     fun before() {
@@ -15,23 +14,23 @@ class CacheOptionsTest {
 
     @Test
     fun `default longTermCacheUrlPattern matches attributes URLs`() {
-        Options.CacheOptions().longTermCacheUrlPattern.assertMatches(
+        Config.CacheConfig().longTermCacheUrlPattern.assertMatches(
             "https://ge.gradle.org/api/builds/tgnsqkb2rhlni/gradle-attributes",
             "https://ge.gradle.org/api/builds/tgnsqkb2rhlni/maven-attributes",
         )
     }
 
     @Test
     fun `default longTermCacheUrlPattern matches build cache performance URLs`() {
-        Options.CacheOptions().longTermCacheUrlPattern.assertMatches(
+        Config.CacheConfig().longTermCacheUrlPattern.assertMatches(
             "https://ge.gradle.org/api/builds/tgnsqkb2rhlni/gradle-build-cache-performance",
             "https://ge.gradle.org/api/builds/tgnsqkb2rhlni/maven-build-cache-performance",
         )
     }
 
     @Test
     fun `default shortTermCacheUrlPattern matches builds URLs`() {
-        Options.CacheOptions().shortTermCacheUrlPattern.assertMatches(
+        Config.CacheConfig().shortTermCacheUrlPattern.assertMatches(
             "https://ge.gradle.org/api/builds?since=0",
             "https://ge.gradle.org/api/builds?since=0&maxBuilds=2",
         )
diff --git a/library/src/test/kotlin/com/gabrielfeo/gradle/enterprise/api/ConfigTest.kt b/library/src/test/kotlin/com/gabrielfeo/gradle/enterprise/api/ConfigTest.kt
@@ -4,7 +4,7 @@ import com.gabrielfeo.gradle.enterprise.api.internal.*
 import org.junit.jupiter.api.assertDoesNotThrow
 import kotlin.test.*
 
-class OptionsTest {
+class ConfigTest {
 
     @BeforeTest
     fun before() {
@@ -17,27 +17,27 @@ class OptionsTest {
     fun `Given no URL set in env, error`() {
         env = FakeEnv()
         assertFails {
-            Options()
+            Config()
         }
     }
 
     @Test
     fun `Given URL set in env, apiUrl is env URL`() {
         (env as FakeEnv)["GRADLE_ENTERPRISE_API_URL"] = "https://example.com/api/"
-        assertEquals("https://example.com/api/", Options().apiUrl)
+        assertEquals("https://example.com/api/", Config().apiUrl)
     }
 
     @Test
     fun `Given macOS and keychain token, keychain token used`() {
         (env as FakeEnv)["GRADLE_ENTERPRISE_API_TOKEN"] = "bar"
         keychain = FakeKeychain("gradle-enterprise-api-token" to "foo")
-        assertEquals("foo", Options().apiToken())
+        assertEquals("foo", Config().apiToken())
     }
 
     @Test
     fun `Given macOS but no keychain token, env token used`() {
         (env as FakeEnv)["GRADLE_ENTERPRISE_API_TOKEN"] = "bar"
-        assertEquals("bar", Options().apiToken())
+        assertEquals("bar", Config().apiToken())
     }
 
     @Test
@@ -48,35 +48,35 @@ class OptionsTest {
                 error("Error: Tried to access macOS keychain in Linux")
         }
         systemProperties = FakeSystemProperties.linux
-        assertEquals("bar", Options().apiToken())
+        assertEquals("bar", Config().apiToken())
     }
 
     @Test
     fun `Given macOS and no token anywhere, error`() {
         assertFails {
-            Options().apiToken()
+            Config().apiToken()
         }
     }
 
     @Test
     fun `Given Linux and no env token, fails`() {
         systemProperties = FakeSystemProperties.linux
         assertFails {
-            Options().apiToken()
+            Config().apiToken()
         }
     }
 
     @Test
     fun `maxConcurrentRequests accepts int`() {
         (env as FakeEnv)["GRADLE_ENTERPRISE_API_MAX_CONCURRENT_REQUESTS"] = "1"
         assertDoesNotThrow {
-            Options().maxConcurrentRequests
+            Config().maxConcurrentRequests
         }
     }
 
     @Test
     fun `Given timeout set in env, readTimeoutMillis returns env value`() {
         (env as FakeEnv)["GRADLE_ENTERPRISE_API_READ_TIMEOUT_MILLIS"] = "100000"
-        assertEquals(100_000L, Options().readTimeoutMillis)
+        assertEquals(100_000L, Config().readTimeoutMillis)
     }
 }
diff --git a/library/src/test/kotlin/com/gabrielfeo/gradle/enterprise/api/OkHttpClientTest.kt b/library/src/test/kotlin/com/gabrielfeo/gradle/enterprise/api/OkHttpClientTest.kt
@@ -92,10 +92,10 @@ class OkHttpClientTest {
         env = fakeEnv
         systemProperties = FakeSystemProperties.macOs
         keychain = FakeKeychain()
-        val options = when (clientBuilder) {
-            null -> Options()
-            else -> Options(clientBuilder = clientBuilder)
+        val config = when (clientBuilder) {
+            null -> Config()
+            else -> Config(clientBuilder = clientBuilder)
         }
-        return buildOkHttpClient(options)
+        return buildOkHttpClient(config)
     }
 }
diff --git a/library/src/test/kotlin/com/gabrielfeo/gradle/enterprise/api/RetrofitTest.kt b/library/src/test/kotlin/com/gabrielfeo/gradle/enterprise/api/RetrofitTest.kt
@@ -34,10 +34,10 @@ class RetrofitTest {
         env = fakeEnv
         systemProperties = FakeSystemProperties.macOs
         keychain = FakeKeychain()
-        val options = Options()
+        val config = Config()
         return buildRetrofit(
-            options = options,
-            client = buildOkHttpClient(options),
+            config = config,
+            client = buildOkHttpClient(config),
             moshi = Moshi.Builder().build()
         )
     }

Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@ import com.gabrielfeo.gradle.enterprise.api.internal.*`
`4`	`4`	`import org.junit.jupiter.api.assertDoesNotThrow`
`5`	`5`	`import kotlin.test.*`
`6`	`6`
`7`		`-class OptionsTest {`
	`7`	`+class ConfigTest {`
`8`	`8`
`9`	`9`	`@BeforeTest`
`10`	`10`	`fun before() {`
`@@ -17,27 +17,27 @@ class OptionsTest {`
`17`	`17`	fun `Given no URL set in env, error`() {
`18`	`18`	`env = FakeEnv()`
`19`	`19`	`assertFails {`
`20`		`- Options()`
	`20`	`+ Config()`
`21`	`21`	`}`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`@Test`
`25`	`25`	fun `Given URL set in env, apiUrl is env URL`() {
`26`	`26`	`(env as FakeEnv)["GRADLE_ENTERPRISE_API_URL"] = "https://example.com/api/"`
`27`		`- assertEquals("https://example.com/api/", Options().apiUrl)`
	`27`	`+ assertEquals("https://example.com/api/", Config().apiUrl)`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`@Test`
`31`	`31`	fun `Given macOS and keychain token, keychain token used`() {
`32`	`32`	`(env as FakeEnv)["GRADLE_ENTERPRISE_API_TOKEN"] = "bar"`
`33`	`33`	`keychain = FakeKeychain("gradle-enterprise-api-token" to "foo")`
`34`		`- assertEquals("foo", Options().apiToken())`
	`34`	`+ assertEquals("foo", Config().apiToken())`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`@Test`
`38`	`38`	fun `Given macOS but no keychain token, env token used`() {
`39`	`39`	`(env as FakeEnv)["GRADLE_ENTERPRISE_API_TOKEN"] = "bar"`
`40`		`- assertEquals("bar", Options().apiToken())`
	`40`	`+ assertEquals("bar", Config().apiToken())`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`@Test`
`@@ -48,35 +48,35 @@ class OptionsTest {`
`48`	`48`	`error("Error: Tried to access macOS keychain in Linux")`
`49`	`49`	`}`
`50`	`50`	`systemProperties = FakeSystemProperties.linux`
`51`		`- assertEquals("bar", Options().apiToken())`
	`51`	`+ assertEquals("bar", Config().apiToken())`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`@Test`
`55`	`55`	fun `Given macOS and no token anywhere, error`() {
`56`	`56`	`assertFails {`
`57`		`- Options().apiToken()`
	`57`	`+ Config().apiToken()`
`58`	`58`	`}`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`@Test`
`62`	`62`	fun `Given Linux and no env token, fails`() {
`63`	`63`	`systemProperties = FakeSystemProperties.linux`
`64`	`64`	`assertFails {`
`65`		`- Options().apiToken()`
	`65`	`+ Config().apiToken()`
`66`	`66`	`}`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`@Test`
`70`	`70`	fun `maxConcurrentRequests accepts int`() {
`71`	`71`	`(env as FakeEnv)["GRADLE_ENTERPRISE_API_MAX_CONCURRENT_REQUESTS"] = "1"`
`72`	`72`	`assertDoesNotThrow {`
`73`		`- Options().maxConcurrentRequests`
	`73`	`+ Config().maxConcurrentRequests`
`74`	`74`	`}`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`@Test`
`78`	`78`	fun `Given timeout set in env, readTimeoutMillis returns env value`() {
`79`	`79`	`(env as FakeEnv)["GRADLE_ENTERPRISE_API_READ_TIMEOUT_MILLIS"] = "100000"`
`80`		`- assertEquals(100_000L, Options().readTimeoutMillis)`
	`80`	`+ assertEquals(100_000L, Config().readTimeoutMillis)`
`81`	`81`	`}`
`82`	`82`	`}`
Original file line number	Diff line number	Diff line change
`@@ -92,10 +92,10 @@ class OkHttpClientTest {`
`92`	`92`	`env = fakeEnv`
`93`	`93`	`systemProperties = FakeSystemProperties.macOs`
`94`	`94`	`keychain = FakeKeychain()`
`95`		`- val options = when (clientBuilder) {`
`96`		`- null -> Options()`
`97`		`- else -> Options(clientBuilder = clientBuilder)`
	`95`	`+ val config = when (clientBuilder) {`
	`96`	`+ null -> Config()`
	`97`	`+ else -> Config(clientBuilder = clientBuilder)`
`98`	`98`	`}`
`99`		`- return buildOkHttpClient(options)`
	`99`	`+ return buildOkHttpClient(config)`
`100`	`100`	`}`
`101`	`101`	`}`
Original file line number	Diff line number	Diff line change
`@@ -34,10 +34,10 @@ class RetrofitTest {`
`34`	`34`	`env = fakeEnv`
`35`	`35`	`systemProperties = FakeSystemProperties.macOs`
`36`	`36`	`keychain = FakeKeychain()`
`37`		`- val options = Options()`
	`37`	`+ val config = Config()`
`38`	`38`	`return buildRetrofit(`
`39`		`- options = options,`
`40`		`- client = buildOkHttpClient(options),`
	`39`	`+ config = config,`
	`40`	`+ client = buildOkHttpClient(config),`
`41`	`41`	`moshi = Moshi.Builder().build()`
`42`	`42`	`)`
`43`	`43`	`}`