extract test-utils module

vasyl-pidlisniak · vasyl-pidlisniak · commit 87a5862068d9 · 2023-05-30T00:58:24.000+02:00
diff --git a/build.gradle.kts b/build.gradle.kts
@@ -65,7 +65,28 @@ subprojects {
         onlyIf { !project.gradle.startParameter.taskNames.contains("publishToMavenLocal") }
     }
 
+    val skipPublishing = project.name == "test-utils" // skip publishing for test utils
+
     tasks {
+        withType<Test> {
+            testLogging {
+                showExceptions = true
+                exceptionFormat = TestExceptionFormat.FULL
+                showStandardStreams = true
+                showCauses = true
+                showStackTraces = true
+                events = setOf(
+                    TestLogEvent.STARTED,
+                    TestLogEvent.FAILED,
+                    TestLogEvent.PASSED,
+                    TestLogEvent.SKIPPED,
+                    TestLogEvent.STANDARD_OUT,
+                    TestLogEvent.STANDARD_ERROR
+                )
+            }
+        }
+
+        if (skipPublishing) return@tasks
 
         val updateVersion by registering(Exec::class) {
             commandLine("npm", "--allow-same-version", "--prefix", projectDir, "version", "${project.property("${project.name}.version")}")
@@ -136,24 +157,6 @@ subprojects {
                 commandLine("npm", "publish")
             }
         }
-
-        withType<Test> {
-            testLogging {
-                showExceptions = true
-                exceptionFormat = TestExceptionFormat.FULL
-                showStandardStreams = true
-                showCauses = true
-                showStackTraces = true
-                events = setOf(
-                    TestLogEvent.STARTED,
-                    TestLogEvent.FAILED,
-                    TestLogEvent.PASSED,
-                    TestLogEvent.SKIPPED,
-                    TestLogEvent.STANDARD_OUT,
-                    TestLogEvent.STANDARD_ERROR
-                )
-            }
-        }
     }
 
     afterEvaluate  {
@@ -181,8 +184,10 @@ subprojects {
         }
     }
 
-    apply(plugin="maven-publish")
-    apply(plugin="signing")
+    if (skipPublishing) return@subprojects
+
+    apply(plugin = "maven-publish")
+    apply(plugin = "signing")
 
 
     configure<PublishingExtension> {
@@ -235,6 +240,7 @@ subprojects {
                 }
             }
         }
+
     }
 }
 
diff --git a/firebase-common/build.gradle.kts b/firebase-common/build.gradle.kts
@@ -90,6 +90,12 @@ kotlin {
             }
         }
 
+        val commonTest by getting {
+            dependencies {
+                implementation(project(":test-utils"))
+            }
+        }
+
         val androidMain by getting {
             dependencies {
                 api("com.google.firebase:firebase-common")
diff --git a/firebase-common/src/commonTest/kotlin/dev/gitlive/firebase/EncodersTest.kt b/firebase-common/src/commonTest/kotlin/dev/gitlive/firebase/EncodersTest.kt
@@ -11,10 +11,6 @@ import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertNull
 
-expect fun nativeMapOf(vararg pairs: Pair<String, Any?>): Any
-expect fun nativeListOf(vararg elements: Any): Any
-expect fun nativeAssertEquals(expected: Any?, actual: Any?): Unit
-
 @Serializable
 data class TestData(val map: Map<String, String>, val bool: Boolean = false, val nullableBool: Boolean? = null)
 
diff --git a/firebase-firestore/build.gradle.kts b/firebase-firestore/build.gradle.kts
@@ -103,6 +103,12 @@ kotlin {
             }
         }
 
+        val commonTest by getting {
+            dependencies {
+                implementation(project(":test-utils"))
+            }
+        }
+
         val androidMain by getting {
             dependencies {
                 api("com.google.firebase:firebase-firestore")
diff --git a/firebase-firestore/src/androidAndroidTest/kotlin/dev/gitlive/firebase/firestore/firestore.kt b/firebase-firestore/src/androidAndroidTest/kotlin/dev/gitlive/firebase/firestore/firestore.kt
@@ -14,8 +14,3 @@ actual val emulatorHost: String = "10.0.2.2"
 actual val context: Any = InstrumentationRegistry.getInstrumentation().targetContext
 
 actual fun runTest(test: suspend CoroutineScope.() -> Unit) = runBlocking { test() }
-
-@Suppress("UNCHECKED_CAST")
-actual fun encodedAsMap(encoded: Any?): Map<String, Any?> = encoded as Map<String, Any?>
-
-actual fun Map<String, Any?>.asEncoded(): Any = this
diff --git a/firebase-firestore/src/commonTest/kotlin/dev/gitlive/firebase/firestore/GeoPointTests.kt b/firebase-firestore/src/commonTest/kotlin/dev/gitlive/firebase/firestore/GeoPointTests.kt
@@ -2,6 +2,8 @@ package dev.gitlive.firebase.firestore
 
 import dev.gitlive.firebase.decode
 import dev.gitlive.firebase.encode
+import dev.gitlive.firebase.nativeAssertEquals
+import dev.gitlive.firebase.nativeMapOf
 import kotlinx.serialization.Serializable
 import kotlin.test.Test
 import kotlin.test.assertEquals
@@ -19,19 +21,20 @@ class GeoPointTests {
     fun encodeGeoPointObject() = runTest {
         val geoPoint = GeoPoint(12.3, 45.6)
         val item = TestDataWithGeoPoint("123", geoPoint)
-        val encoded = encodedAsMap(encode(item, shouldEncodeElementDefault = false))
-        assertEquals("123", encoded["uid"])
         // check GeoPoint is encoded to a platform representation
-        assertEquals(geoPoint.nativeValue, encoded["location"])
+        nativeAssertEquals(
+            nativeMapOf("uid" to "123", "location" to geoPoint.nativeValue),
+            encode(item, shouldEncodeElementDefault = false)
+        )
     }
 
     @Test
     fun decodeGeoPointObject() = runTest {
         val geoPoint = GeoPoint(12.3, 45.6)
-        val obj = mapOf(
+        val obj = nativeMapOf(
             "uid" to "123",
             "location" to geoPoint.nativeValue
-        ).asEncoded()
+        )
         val decoded: TestDataWithGeoPoint = decode(obj)
         assertEquals("123", decoded.uid)
         // check a platform GeoPoint is properly wrapped
diff --git a/firebase-firestore/src/commonTest/kotlin/dev/gitlive/firebase/firestore/TimestampTests.kt b/firebase-firestore/src/commonTest/kotlin/dev/gitlive/firebase/firestore/TimestampTests.kt
@@ -3,8 +3,12 @@ package dev.gitlive.firebase.firestore
 import dev.gitlive.firebase.decode
 import dev.gitlive.firebase.encode
 import dev.gitlive.firebase.firebaseSerializer
+import dev.gitlive.firebase.nativeAssertEquals
+import dev.gitlive.firebase.nativeMapOf
 import kotlinx.serialization.Serializable
 import kotlin.test.*
+import kotlin.time.Duration.Companion.milliseconds
+import kotlin.time.DurationUnit
 
 @Serializable
 data class TestData(
@@ -29,34 +33,41 @@ class TimestampTests {
     fun encodeTimestampObject() = runTest {
         val timestamp = Timestamp(123, 456)
         val item = TestData("uid123", timestamp, timestamp, null)
-        val encoded = encodedAsMap(encode(item, shouldEncodeElementDefault = false))
-        assertEquals("uid123", encoded["uid"])
-        // NOTE: wrapping is required because JS does not override equals
-        assertEquals(timestamp, Timestamp(encoded["createdAt"] as NativeTimestamp))
-        assertEquals(timestamp, Timestamp(encoded["updatedAt"] as NativeTimestamp))
-        assertNull(encoded["deletedAt"])
+        nativeAssertEquals(
+            nativeMapOf(
+                "uid" to "uid123",
+                "createdAt" to timestamp.nativeValue,
+                "updatedAt" to timestamp.nativeValue,
+                "deletedAt" to null
+            ),
+            encode(item, shouldEncodeElementDefault = false)
+        )
     }
 
     @Test
     fun encodeServerTimestampObject() = runTest {
         val timestamp = Timestamp(123, 456)
         val item = TestData("uid123", timestamp, Timestamp.ServerTimestamp, Timestamp.ServerTimestamp)
-        val encoded = encodedAsMap(encode(item, shouldEncodeElementDefault = false))
-        assertEquals("uid123", encoded["uid"])
-        assertEquals(timestamp, Timestamp(encoded["createdAt"] as NativeTimestamp))
-        assertEquals(FieldValue.serverTimestamp, FieldValue(encoded["updatedAt"]!!))
-        assertEquals(FieldValue.serverTimestamp, FieldValue(encoded["deletedAt"]!!))
+        nativeAssertEquals(
+            nativeMapOf(
+                "uid" to "uid123",
+                "createdAt" to timestamp.nativeValue,
+                "updatedAt" to FieldValue.serverTimestamp.nativeValue,
+                "deletedAt" to FieldValue.serverTimestamp.nativeValue
+            ),
+            encode(item, shouldEncodeElementDefault = false)
+        )
     }
 
     @Test
     fun decodeTimestampObject() = runTest {
         val timestamp = Timestamp(123, 345)
-        val obj = mapOf(
+        val obj = nativeMapOf(
             "uid" to "uid123",
             "createdAt" to timestamp.nativeValue,
             "updatedAt" to timestamp.nativeValue,
             "deletedAt" to timestamp.nativeValue
-        ).asEncoded()
+        )
         val decoded: TestData = decode(obj)
         assertEquals("uid123", decoded.uid)
         with(decoded.createdAt) {
@@ -78,12 +89,12 @@ class TimestampTests {
 
     @Test
     fun decodeEmptyTimestampObject() = runTest {
-        val obj = mapOf(
+        val obj = nativeMapOf(
             "uid" to "uid123",
             "createdAt" to Timestamp.now().nativeValue,
             "updatedAt" to Timestamp.now().nativeValue,
             "deletedAt" to null
-        ).asEncoded()
+        )
         val decoded: TestData = decode(obj)
         assertEquals("uid123", decoded.uid)
         assertNotNull(decoded.updatedAt)
@@ -100,21 +111,17 @@ class TimestampTests {
 
     @Test
     fun timestampMillisecondsConversion() = runTest {
-        val duration = 1666170858063.milliseconds
-        val (seconds, nanoseconds) = ms.toComponents { seconds, nanoseconds -> seconds to nanoseconds }
-        val ms = duration.toDouble(DurationUnit.MILLISECONDS)
+        val ms = 1666170858063.0
 
         val timestamp = Timestamp.fromMilliseconds(ms)
-        assertEquals(seconds, timestamp.seconds)
-        assertEquals(nanoseconds, timestamp.nanoseconds)
         assertEquals(ms, timestamp.toMilliseconds())
     }
 
     @Test
     fun timestampDurationConversion() = runTest {
         val duration = 1666170858063.milliseconds
-        val (seconds, nanoseconds) = ms.toComponents { seconds, nanoseconds -> seconds to nanoseconds }
-        val timestamp = Timestamp.fromDuration(ms)
+        val (seconds, nanoseconds) = duration.toComponents { seconds, nanoseconds -> seconds to nanoseconds }
+        val timestamp = Timestamp.fromDuration(duration)
         assertEquals(seconds, timestamp.seconds)
         assertEquals(nanoseconds, timestamp.nanoseconds)
         assertEquals(duration, timestamp.toDuration())
diff --git a/firebase-firestore/src/commonTest/kotlin/dev/gitlive/firebase/firestore/firestore.kt b/firebase-firestore/src/commonTest/kotlin/dev/gitlive/firebase/firestore/firestore.kt
@@ -28,11 +28,6 @@ expect val emulatorHost: String
 expect val context: Any
 expect fun runTest(test: suspend CoroutineScope.() -> Unit)
 
-/** @return a map extracted from the encoded data. */
-expect fun encodedAsMap(encoded: Any?): Map<String, Any?>
-/** @return pairs as raw encoded data. */
-expect fun Map<String, Any?>.asEncoded(): Any
-
 class FirebaseFirestoreTest {
 
     @Serializable
diff --git a/firebase-firestore/src/iosTest/kotlin/dev/gitlive/firebase/firestore/firestore.kt b/firebase-firestore/src/iosTest/kotlin/dev/gitlive/firebase/firestore/firestore.kt
@@ -22,8 +22,3 @@ actual fun runTest(test: suspend CoroutineScope.() -> Unit) = runBlocking {
     }
     testRun.await()
 }
-
-@Suppress("UNCHECKED_CAST")
-actual fun encodedAsMap(encoded: Any?): Map<String, Any?> = encoded as Map<String, Any?>
-
-actual fun Map<String, Any?>.asEncoded(): Any = this
diff --git a/firebase-firestore/src/jsTest/kotlin/dev/gitlive/firebase/firestore/firestore.kt b/firebase-firestore/src/jsTest/kotlin/dev/gitlive/firebase/firestore/firestore.kt
@@ -15,11 +15,3 @@ actual val context: Any = Unit
 actual fun runTest(test: suspend CoroutineScope.() -> Unit) {
     runTest { test() }
 }
-
-actual fun encodedAsMap(encoded: Any?): Map<String, Any?> {
-    return (js("Object").entries(encoded) as Array<Array<Any>>).associate {
-        it[0] as String to it[1]
-    }
-}
-actual fun Map<String, Any?>.asEncoded(): Any =
-    json(*entries.map { (key, value) -> key to value }.toTypedArray())
diff --git a/settings.gradle.kts b/settings.gradle.kts
@@ -8,7 +8,8 @@ include(
     "firebase-functions",
     "firebase-installations",
     "firebase-perf",
-    "firebase-crashlytics"
+    "firebase-crashlytics",
+    "test-utils"
 )
 
 //enableFeaturePreview("GRADLE_METADATA")
diff --git a/test-utils/build.gradle.kts b/test-utils/build.gradle.kts
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2023 GitLive Ltd.  Use of this source code is governed by the Apache 2.0 license.
+ */
+
+// this project is used only in tests to share common code. publishing is disabled in the root build.gradle.kts
+
+version = "0.0.1"
+
+plugins {
+    id("com.android.library")
+    kotlin("multiplatform")
+    kotlin("plugin.serialization") version "1.8.20"
+}
+
+android {
+    compileSdk = property("targetSdkVersion") as Int
+    defaultConfig {
+        minSdk = property("minSdkVersion") as Int
+        targetSdk = property("targetSdkVersion") as Int
+        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+    }
+    sourceSets {
+        getByName("main") {
+            manifest.srcFile("src/androidMain/AndroidManifest.xml")
+        }
+    }
+    packagingOptions {
+        resources.pickFirsts.add("META-INF/kotlinx-serialization-core.kotlin_module")
+        resources.pickFirsts.add("META-INF/AL2.0")
+        resources.pickFirsts.add("META-INF/LGPL2.1")
+    }
+    lint {
+        abortOnError = false
+    }
+}
+
+kotlin {
+
+    android {
+        publishAllLibraryVariants()
+    }
+
+    val supportIosTarget = project.property("skipIosTarget") != "true"
+
+    if (supportIosTarget) {
+        ios()
+        iosSimulatorArm64()
+    }
+
+    js {
+        useCommonJs()
+    }
+
+    sourceSets {
+        all {
+            languageSettings.apply {
+                apiVersion = "1.8"
+                languageVersion = "1.8"
+                progressiveMode = true
+            }
+        }
+
+        val commonMain by getting {
+            dependencies {
+                implementation(kotlin("test"))
+            }
+        }
+
+        if (supportIosTarget) {
+            val iosMain by getting
+            val iosSimulatorArm64Main by getting
+            iosSimulatorArm64Main.dependsOn(iosMain)
+            val iosTest by sourceSets.getting
+            val iosSimulatorArm64Test by getting
+            iosSimulatorArm64Test.dependsOn(iosTest)
+        }
+
+        val jsMain by getting
+    }
+}
diff --git a/test-utils/src/androidMain/AndroidManifest.xml b/test-utils/src/androidMain/AndroidManifest.xml
@@ -0,0 +1 @@
+<manifest package="dev.gitlive.firebase.testUtils"/>
diff --git a/test-utils/src/androidMain/kotlin/dev/gitlive/firebase/TestUtils.kt b/test-utils/src/androidMain/kotlin/dev/gitlive/firebase/TestUtils.kt
@@ -6,4 +6,6 @@ package dev.gitlive.firebase
 
 actual fun nativeMapOf(vararg pairs: Pair<String, Any?>): Any = mapOf(*pairs)
 actual fun nativeListOf(vararg elements: Any): Any = listOf(*elements)
-actual fun nativeAssertEquals(expected: Any?, actual: Any?)  = kotlin.test.assertEquals(expected, actual)
+actual fun nativeAssertEquals(expected: Any?, actual: Any?) {
+    kotlin.test.assertEquals(expected, actual)
+}
diff --git a/test-utils/src/commonMain/kotlin/dev/gitlive/firebase/TestUtils.kt b/test-utils/src/commonMain/kotlin/dev/gitlive/firebase/TestUtils.kt
diff --git a/test-utils/src/iosMain/kotlin/dev/gitlive/firebase/TestUtils.kt b/test-utils/src/iosMain/kotlin/dev/gitlive/firebase/TestUtils.kt
diff --git a/test-utils/src/jsMain/kotlin/dev/gitlive/firebase/TestUtils.kt b/test-utils/src/jsMain/kotlin/dev/gitlive/firebase/TestUtils.kt

Original file line number	Diff line number	Diff line change
`@@ -90,6 +90,12 @@ kotlin {`
`90`	`90`	`}`
`91`	`91`	`}`
`92`	`92`
	`93`	`+ val commonTest by getting {`
	`94`	`+ dependencies {`
	`95`	`+ implementation(project(":test-utils"))`
	`96`	`+ }`
	`97`	`+ }`
	`98`	`+`
`93`	`99`	`val androidMain by getting {`
`94`	`100`	`dependencies {`
`95`	`101`	`api("com.google.firebase:firebase-common")`
Original file line number	Diff line number	Diff line change
`@@ -103,6 +103,12 @@ kotlin {`
`103`	`103`	`}`
`104`	`104`	`}`
`105`	`105`
	`106`	`+ val commonTest by getting {`
	`107`	`+ dependencies {`
	`108`	`+ implementation(project(":test-utils"))`
	`109`	`+ }`
	`110`	`+ }`
	`111`	`+`
`106`	`112`	`val androidMain by getting {`
`107`	`113`	`dependencies {`
`108`	`114`	`api("com.google.firebase:firebase-firestore")`
Original file line number	Diff line number	Diff line change
`@@ -22,8 +22,3 @@ actual fun runTest(test: suspend CoroutineScope.() -> Unit) = runBlocking {`
`22`	`22`	`}`
`23`	`23`	`testRun.await()`
`24`	`24`	`}`
`25`		`-`
`26`		`-@Suppress("UNCHECKED_CAST")`
`27`		`-actual fun encodedAsMap(encoded: Any?): Map<String, Any?> = encoded as Map<String, Any?>`
`28`		`-`
`29`		`-actual fun Map<String, Any?>.asEncoded(): Any = this`