Merge branch 'main' into daymon-bump-protobuf

Author: daymxn

.github/workflows/ci_tests.yml

@@ -167,7 +167,7 @@ jobs:
 
     steps:
       - name: Download Artifacts
-        uses: actions/[email protected].5
+        uses: actions/[email protected].7
         with:
           path: artifacts
 

firebase-dataconnect/androidTestutil/androidTestutil.gradle.kts

@@ -58,6 +58,7 @@ dependencies {
   implementation(libs.androidx.test.core)
   implementation(libs.androidx.test.junit)
   implementation(libs.auth0.jwt)
+  implementation(libs.kotest.assertions)
   implementation(libs.kotest.property)
   implementation(libs.kotlinx.coroutines.core)
   implementation(libs.kotlinx.serialization.core)

firebase-dataconnect/androidTestutil/src/test/kotlin/com/google/firebase/dataconnect/testutil/DataConnectBackendUnitTest.kt

@@ -16,118 +16,123 @@
 
 package com.google.firebase.dataconnect.testutil
 
-import com.google.common.truth.Truth.assertThat
 import com.google.firebase.dataconnect.testutil.DataConnectBackend.Companion.fromInstrumentationArgument
+import io.kotest.assertions.assertSoftly
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.matchers.nulls.shouldBeNull
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.types.shouldBeSameInstanceAs
 import java.net.URI
 import java.net.URL
 import org.junit.Test
 
 class DataConnectBackendUnitTest {
 
   @Test
-  fun `fromInstrumentationArgument(null) should return Production`() {
-    assertThat(fromInstrumentationArgument(null)).isNull()
+  fun `fromInstrumentationArgument(null) should return null`() {
+    fromInstrumentationArgument(null).shouldBeNull()
   }
 
   @Test
   fun `fromInstrumentationArgument('prod') should return Production`() {
-    assertThat(fromInstrumentationArgument("prod")).isSameInstanceAs(DataConnectBackend.Production)
+    fromInstrumentationArgument("prod") shouldBeSameInstanceAs DataConnectBackend.Production
   }
 
   @Test
   fun `fromInstrumentationArgument('staging') should return Staging`() {
-    assertThat(fromInstrumentationArgument("staging")).isSameInstanceAs(DataConnectBackend.Staging)
+    fromInstrumentationArgument("staging") shouldBeSameInstanceAs DataConnectBackend.Staging
   }
 
   @Test
   fun `fromInstrumentationArgument('autopush') should return Autopush`() {
-    assertThat(fromInstrumentationArgument("autopush"))
-      .isSameInstanceAs(DataConnectBackend.Autopush)
+    fromInstrumentationArgument("autopush") shouldBeSameInstanceAs DataConnectBackend.Autopush
   }
 
   @Test
   fun `fromInstrumentationArgument('emulator') should return Emulator()`() {
-    assertThat(fromInstrumentationArgument("emulator")).isEqualTo(DataConnectBackend.Emulator())
+    fromInstrumentationArgument("emulator") shouldBe DataConnectBackend.Emulator()
   }
 
   @Test
   fun `fromInstrumentationArgument(emulator with host) should return Emulator() with the host`() {
-    assertThat(fromInstrumentationArgument("emulator:a.b.c"))
-      .isEqualTo(DataConnectBackend.Emulator(host = "a.b.c"))
+    fromInstrumentationArgument("emulator:a.b.c") shouldBe
+      DataConnectBackend.Emulator(host = "a.b.c")
   }
 
   @Test
   fun `fromInstrumentationArgument(emulator with port) should return Emulator() with the port`() {
-    assertThat(fromInstrumentationArgument("emulator::9987"))
-      .isEqualTo(DataConnectBackend.Emulator(port = 9987))
+    fromInstrumentationArgument("emulator::9987") shouldBe DataConnectBackend.Emulator(port = 9987)
   }
 
   @Test
   fun `fromInstrumentationArgument(emulator with host and port) should return Emulator() with the host and port`() {
-    assertThat(fromInstrumentationArgument("emulator:a.b.c:9987"))
-      .isEqualTo(DataConnectBackend.Emulator(host = "a.b.c", port = 9987))
+    fromInstrumentationArgument("emulator:a.b.c:9987") shouldBe
+      DataConnectBackend.Emulator(host = "a.b.c", port = 9987)
   }
 
   @Test
   fun `fromInstrumentationArgument(http url with host) should return Custom()`() {
-    assertThat(fromInstrumentationArgument("http://a.b.c"))
-      .isEqualTo(DataConnectBackend.Custom("a.b.c", false))
+    fromInstrumentationArgument("http://a.b.c") shouldBe DataConnectBackend.Custom("a.b.c", false)
   }
 
   @Test
   fun `fromInstrumentationArgument(http url with host and port) should return Custom()`() {
-    assertThat(fromInstrumentationArgument("http://a.b.c:9987"))
-      .isEqualTo(DataConnectBackend.Custom("a.b.c:9987", false))
+    fromInstrumentationArgument("http://a.b.c:9987") shouldBe
+      DataConnectBackend.Custom("a.b.c:9987", false)
   }
 
   @Test
   fun `fromInstrumentationArgument(https url with host) should return Custom()`() {
-    assertThat(fromInstrumentationArgument("https://a.b.c"))
-      .isEqualTo(DataConnectBackend.Custom("a.b.c", true))
+    fromInstrumentationArgument("https://a.b.c") shouldBe DataConnectBackend.Custom("a.b.c", true)
   }
 
   @Test
   fun `fromInstrumentationArgument(https url with host and port) should return Custom()`() {
-    assertThat(fromInstrumentationArgument("https://a.b.c:9987"))
-      .isEqualTo(DataConnectBackend.Custom("a.b.c:9987", true))
+    fromInstrumentationArgument("https://a.b.c:9987") shouldBe
+      DataConnectBackend.Custom("a.b.c:9987", true)
   }
 
   @Test
   fun `fromInstrumentationArgument('foo') should throw an exception`() {
     val exception =
-      assertThrows(InvalidInstrumentationArgumentException::class) {
-        fromInstrumentationArgument("foo")
-      }
+      shouldThrow<InvalidInstrumentationArgumentException> { fromInstrumentationArgument("foo") }
+
     val urlParseErrorMessage = runCatching { URL("foo") }.exceptionOrNull()!!.message!!
-    assertThat(exception).hasMessageThat().containsWithNonAdjacentText("foo")
-    assertThat(exception).hasMessageThat().containsWithNonAdjacentText("invalid", ignoreCase = true)
-    assertThat(exception).hasMessageThat().containsWithNonAdjacentText("DATA_CONNECT_BACKEND")
-    assertThat(exception).hasMessageThat().containsWithNonAdjacentText(urlParseErrorMessage)
+    assertSoftly {
+      exception.message shouldContainWithNonAbuttingText "foo"
+      exception.message shouldContainWithNonAbuttingTextIgnoringCase "invalid"
+      exception.message shouldContainWithNonAbuttingText "DATA_CONNECT_BACKEND"
+      exception.message shouldContainWithNonAbuttingText urlParseErrorMessage
+    }
   }
 
   @Test
   fun `fromInstrumentationArgument(invalid URI) should throw an exception`() {
     val exception =
-      assertThrows(InvalidInstrumentationArgumentException::class) {
-        fromInstrumentationArgument("..:")
-      }
+      shouldThrow<InvalidInstrumentationArgumentException> { fromInstrumentationArgument("..:") }
+
     val uriParseErrorMessage = runCatching { URI("..:") }.exceptionOrNull()!!.message!!
-    assertThat(exception).hasMessageThat().containsWithNonAdjacentText("..:")
-    assertThat(exception).hasMessageThat().containsWithNonAdjacentText("invalid", ignoreCase = true)
-    assertThat(exception).hasMessageThat().containsWithNonAdjacentText("DATA_CONNECT_BACKEND")
-    assertThat(exception).hasMessageThat().containsWithNonAdjacentText(uriParseErrorMessage)
+    assertSoftly {
+      exception.message shouldContainWithNonAbuttingText "..:"
+      exception.message shouldContainWithNonAbuttingTextIgnoringCase "invalid"
+      exception.message shouldContainWithNonAbuttingText "DATA_CONNECT_BACKEND"
+      exception.message shouldContainWithNonAbuttingText uriParseErrorMessage
+    }
   }
 
   @Test
   fun `fromInstrumentationArgument(invalid emulator URI) should throw an exception`() {
     val exception =
-      assertThrows(InvalidInstrumentationArgumentException::class) {
+      shouldThrow<InvalidInstrumentationArgumentException> {
         fromInstrumentationArgument("emulator:::::")
       }
+
     val urlParseErrorMessage = runCatching { URL("https://::::") }.exceptionOrNull()!!.message!!
-    assertThat(exception).hasMessageThat().containsWithNonAdjacentText("emulator:::::")
-    assertThat(exception).hasMessageThat().containsWithNonAdjacentText("invalid", ignoreCase = true)
-    assertThat(exception).hasMessageThat().containsWithNonAdjacentText("DATA_CONNECT_BACKEND")
-    assertThat(exception).hasMessageThat().containsWithNonAdjacentText(urlParseErrorMessage)
+    assertSoftly {
+      exception.message shouldContainWithNonAbuttingText "emulator:::::"
+      exception.message shouldContainWithNonAbuttingTextIgnoringCase "invalid"
+      exception.message shouldContainWithNonAbuttingText "DATA_CONNECT_BACKEND"
+      exception.message shouldContainWithNonAbuttingText urlParseErrorMessage
+    }
   }
 }

firebase-dataconnect/gradleplugin/plugin/src/main/kotlin/com/google/firebase/dataconnect/gradle/plugin/DataConnectExecutable.kt

@@ -15,43 +15,11 @@
  */
 package com.google.firebase.dataconnect.gradle.plugin
 
-import java.io.InputStream
-import kotlinx.serialization.ExperimentalSerializationApi
-import kotlinx.serialization.json.Json
-import kotlinx.serialization.json.decodeFromStream
-
 sealed interface DataConnectExecutable {
 
   data class File(val file: java.io.File) : DataConnectExecutable
 
   data class RegularFile(val file: org.gradle.api.file.RegularFile) : DataConnectExecutable
 
-  data class Version(val version: String) : DataConnectExecutable {
-    companion object {
-      val default: Version
-        get() = Version(VersionsJson.load().default)
-    }
-  }
-
-  @OptIn(ExperimentalSerializationApi::class)
-  object VersionsJson {
-
-    const val RESOURCE_PATH =
-      "com/google/firebase/dataconnect/gradle/plugin/DataConnectExecutableVersions.json"
-
-    fun load(): Root = openFile().use { Json.decodeFromStream<Root>(it) }
-
-    private fun openFile(): InputStream =
-      this::class.java.classLoader.getResourceAsStream(RESOURCE_PATH)
-        ?: throw DataConnectGradleException("antkaw2gjp", "resource not found: $RESOURCE_PATH")
-
-    @kotlinx.serialization.Serializable
-    data class Root(
-      val default: String,
-      val versions: Map<String, VerificationInfo>,
-    )
-
-    @kotlinx.serialization.Serializable
-    data class VerificationInfo(val size: Long, val sha512DigestHex: String)
-  }
+  data class Version(val version: String) : DataConnectExecutable
 }