Implement and test realtime debug functions

Author: tom-andersen

firebase-firestore/src/main/java/com/google/firebase/firestore/pipeline/EvaluateResult.kt

@@ -7,10 +7,8 @@ import com.google.protobuf.Timestamp
 
 internal sealed class EvaluateResult(val value: Value?) {
   abstract val isError: Boolean
-  val isSuccess: Boolean
-    get() = this is EvaluateResultValue
-  val isUnset: Boolean
-    get() = this is EvaluateResultUnset
+  abstract val isSuccess: Boolean
+  abstract val isUnset: Boolean
 
   companion object {
     val TRUE: EvaluateResultValue = EvaluateResultValue(Values.TRUE_VALUE)
@@ -33,14 +31,21 @@ internal sealed class EvaluateResult(val value: Value?) {
   }
 }
 
+internal class EvaluateResultValue(value: Value) : EvaluateResult(value) {
+  override val isSuccess: Boolean = true
+  override val isError: Boolean = false
+  override val isUnset: Boolean = false
+}
+
 internal object EvaluateResultError : EvaluateResult(null) {
+  override val isSuccess: Boolean = false
   override val isError: Boolean = true
+  override val isUnset: Boolean = false
 }
 
 internal object EvaluateResultUnset : EvaluateResult(null) {
+  override val isSuccess: Boolean = false
   override val isError: Boolean = false
+  override val isUnset: Boolean = true
 }
 
-internal class EvaluateResultValue(value: Value) : EvaluateResult(value) {
-  override val isError: Boolean = false
-}

firebase-firestore/src/main/java/com/google/firebase/firestore/pipeline/evaluation.kt

@@ -33,9 +33,21 @@ internal typealias EvaluateFunction = (params: List<EvaluateDocument>) -> Evalua
 
 internal val notImplemented: EvaluateFunction = { _ -> throw NotImplementedError() }
 
+// === Debug Functions ===
+
+internal val evaluateIsError: EvaluateFunction = unaryFunction { r: EvaluateResult ->
+  EvaluateResult.boolean(r.isError)
+}
+
 // === Logical Functions ===
 
-internal val evaluateExists: EvaluateFunction = notImplemented
+internal val evaluateExists: EvaluateFunction = unaryFunction { r: EvaluateResult ->
+  when (r) {
+    EvaluateResultError -> r
+    EvaluateResultUnset -> EvaluateResult.FALSE
+    is EvaluateResultValue -> EvaluateResult.TRUE
+  }
+}
 
 internal val evaluateAnd: EvaluateFunction = { params ->
   fun(input: MutableDocument): EvaluateResult {
@@ -492,18 +504,22 @@ private inline fun catch(f: () -> EvaluateResult): EvaluateResult =
     EvaluateResultError
   }
 
-@JvmName("unaryValueFunction")
 private inline fun unaryFunction(
-  crossinline function: (Value) -> EvaluateResult
+  crossinline function: (EvaluateResult) -> EvaluateResult
 ): EvaluateFunction = { params ->
   if (params.size != 1)
     throw Assert.fail("Function should have exactly 1 params, but %d were given.", params.size)
   val p = params[0]
-  block@{ input: MutableDocument ->
-    val v = p(input).value ?: return@block EvaluateResultError
-    if (v.hasNullValue()) return@block EvaluateResult.NULL
-    catch { function(v) }
-  }
+  { input: MutableDocument -> catch { function(p(input)) } }
+}
+
+@JvmName("unaryValueFunction")
+private inline fun unaryFunction(
+  crossinline function: (Value) -> EvaluateResult
+): EvaluateFunction = unaryFunction { r: EvaluateResult ->
+  val v = r.value
+  if (v === null) EvaluateResultError
+  else if (v.hasNullValue()) EvaluateResult.NULL else function(v)
 }
 
 @JvmName("unaryBooleanFunction")
@@ -563,17 +579,12 @@ private inline fun <T> unaryFunctionType(
   valueTypeCase: Value.ValueTypeCase,
   crossinline valueExtractor: (Value) -> T,
   crossinline function: (T) -> EvaluateResult
-): EvaluateFunction = { params ->
-  if (params.size != 1)
-    throw Assert.fail("Function should have exactly 1 params, but %d were given.", params.size)
-  val p = params[0]
-  block@{ input: MutableDocument ->
-    val v = p(input).value ?: return@block EvaluateResultError
-    when (v.valueTypeCase) {
-      Value.ValueTypeCase.NULL_VALUE -> EvaluateResult.NULL
-      valueTypeCase -> catch { function(valueExtractor(v)) }
-      else -> EvaluateResultError
-    }
+): EvaluateFunction = unaryFunction { r: EvaluateResult ->
+  val v = r.value
+  if (v === null) EvaluateResultError else  when (v.valueTypeCase) {
+    Value.ValueTypeCase.NULL_VALUE -> EvaluateResult.NULL
+    valueTypeCase -> catch { function(valueExtractor(v)) }
+    else -> EvaluateResultError
   }
 }
 

firebase-firestore/src/main/java/com/google/firebase/firestore/pipeline/expressions.kt

@@ -27,6 +27,7 @@ import com.google.firebase.firestore.model.FieldPath as ModelFieldPath
 import com.google.firebase.firestore.model.MutableDocument
 import com.google.firebase.firestore.model.Values
 import com.google.firebase.firestore.model.Values.encodeValue
+import com.google.firebase.firestore.pipeline.Expr.Companion
 import com.google.firebase.firestore.pipeline.Expr.Companion.field
 import com.google.firebase.firestore.util.CustomClassMapper
 import com.google.firestore.v1.MapValue
@@ -2979,6 +2980,14 @@ abstract class Expr internal constructor() {
     fun ifError(tryExpr: BooleanExpr, catchExpr: BooleanExpr): BooleanExpr =
       BooleanExpr("if_error", notImplemented, tryExpr, catchExpr)
 
+    /**
+     * Creates an expression that checks if a given expression produces an error.
+     *
+     * @param expr The expression to check.
+     * @return A new [BooleanExpr] representing the `isError` check.
+     */
+    @JvmStatic fun isError(expr: Expr): BooleanExpr = BooleanExpr("is_error", evaluateIsError, expr)
+
     /**
      * Creates an expression that returns the [catchValue] argument if there is an error, else
      * return the result of the [tryExpr] argument evaluation.
@@ -4082,6 +4091,13 @@ abstract class Expr internal constructor() {
    */
   fun ifError(catchValue: Any): Expr = Companion.ifError(this, catchValue)
 
+  /**
+   * Creates an expression that checks if this expression produces an error.
+   *
+   * @return A new [BooleanExpr] representing the `isError` check.
+   */
+  fun isError(): BooleanExpr = Companion.isError(this)
+
   internal abstract fun toProto(userDataReader: UserDataReader): Value
 
   internal abstract fun evaluateContext(context: EvaluationContext): EvaluateDocument
@@ -4145,7 +4161,7 @@ class Field internal constructor(private val fieldPath: ModelFieldPath) : Select
 
   private fun evaluateInternal(input: MutableDocument): EvaluateResult {
     val value: Value? = input.getField(fieldPath)
-    return if (value == null) EvaluateResultUnset else EvaluateResultValue(value)
+    return if (value === null) EvaluateResultUnset else EvaluateResultValue(value)
   }
 }
 
@@ -4311,6 +4327,18 @@ internal constructor(name: String, function: EvaluateFunction, params: Array<out
    * @return A new [BooleanExpr] representing the not operation.
    */
   fun not(): BooleanExpr = Expr.Companion.not(this)
+
+  /**
+   * Creates an expression that returns the [catchExpr] argument if there is an error, else return
+   * the result of this expression.
+   *
+   * This overload will return [BooleanExpr] because the [catchExpr] is a [BooleanExpr].
+   *
+   * @param catchExpr The catch expression that will be evaluated and returned if the this
+   * expression produces an error.
+   * @return A new [BooleanExpr] representing the ifError operation.
+   */
+  fun ifError(catchExpr: BooleanExpr): BooleanExpr = Expr.Companion.ifError(this, catchExpr)
 }
 
 /**

firebase-firestore/src/test/java/com/google/firebase/firestore/pipeline/DebugTests.kt

@@ -0,0 +1,112 @@
+package com.google.firebase.firestore.pipeline
+
+import com.google.firebase.firestore.pipeline.Expr.Companion.array
+import com.google.firebase.firestore.pipeline.Expr.Companion.arrayLength
+import com.google.firebase.firestore.pipeline.Expr.Companion.constant
+import com.google.firebase.firestore.pipeline.Expr.Companion.exists
+import com.google.firebase.firestore.pipeline.Expr.Companion.field
+import com.google.firebase.firestore.pipeline.Expr.Companion.isError
+import com.google.firebase.firestore.pipeline.Expr.Companion.map
+import com.google.firebase.firestore.pipeline.Expr.Companion.not
+import com.google.firebase.firestore.pipeline.Expr.Companion.nullValue
+import com.google.firebase.firestore.testutil.TestUtil
+import com.google.firebase.firestore.testutil.TestUtil.doc
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+@RunWith(RobolectricTestRunner::class)
+class DebugTests {
+
+  // --- Exists Tests ---
+
+  @Test
+  fun `valid field returns true for exists`() {
+    val existsExpr = exists(field("x"))
+    val doc = doc("coll/doc1", 1, mapOf("x" to 1))
+    assertEvaluatesTo(evaluate(existsExpr, doc), true, "exists(existent-field))")
+  }
+
+  @Test
+  fun `anything but unset returns true for exists`() {
+    ComparisonTestData.allSupportedComparableValues.forEach { valueExpr ->
+      assertEvaluatesTo(evaluate(exists(valueExpr)), true, "exists(%s)", valueExpr)
+    }
+  }
+
+  @Test
+  fun `null returns true for exists`() {
+    assertEvaluatesTo(evaluate(exists(nullValue())), true, "exists(null)")
+  }
+
+  @Test
+  fun `error returns error for exists`() {
+    val errorProducingExpr = arrayLength(constant("notAnArray"))
+    assertEvaluatesToError(evaluate(exists(errorProducingExpr)), "exists(error_expr)")
+  }
+
+  @Test
+  fun `unset with not exists returns true`() {
+    val unsetExpr = field("non-existent-field")
+    val existsExpr = exists(unsetExpr)
+    assertEvaluatesTo(evaluate(not(existsExpr)), true, "not(exists(non-existent-field))")
+  }
+
+  @Test
+  fun `unset returns false for exists`() {
+    val unsetExpr = field("non-existent-field")
+    assertEvaluatesTo(evaluate(exists(unsetExpr)), false, "exists(non-existent-field)")
+  }
+
+  @Test
+  fun `empty array returns true for exists`() {
+    assertEvaluatesTo(evaluate(exists(array())), true, "exists([])")
+  }
+
+  @Test
+  fun `empty map returns true for exists`() {
+    // Expr.map() creates an empty map expression
+    assertEvaluatesTo(evaluate(exists(map(emptyMap()))), true, "exists({})")
+  }
+
+  // --- IsError Tests ---
+
+  @Test
+  fun `isError error returns true`() {
+    val errorProducingExpr = arrayLength(constant("notAnArray"))
+    assertEvaluatesTo(evaluate(isError(errorProducingExpr)), true, "isError(error_expr)")
+  }
+
+  @Test
+  fun `isError field missing returns false`() {
+    // Evaluating a missing field results in UNSET. isError(UNSET) should be false.
+    val fieldExpr = field("target")
+    assertEvaluatesTo(evaluate(isError(fieldExpr)), false, "isError(missing_field)")
+  }
+
+  @Test
+  fun `isError non-error returns false`() {
+    assertEvaluatesTo(evaluate(isError(constant(42L))), false, "isError(42L)")
+  }
+
+  @Test
+  fun `isError explicit null returns false`() {
+    assertEvaluatesTo(evaluate(isError(nullValue())), false, "isError(null)")
+  }
+
+  @Test
+  fun `isError unset returns false`() {
+    // Evaluating a non-existent field results in UNSET. isError(UNSET) should be false.
+    val unsetExpr = field("non-existent-field")
+    assertEvaluatesTo(evaluate(isError(unsetExpr)), false, "isError(non-existent-field)")
+  }
+
+  @Test
+  fun `isError anything but error returns false`() {
+    ComparisonTestData.allSupportedComparableValues.forEach { valueExpr ->
+      assertEvaluatesTo(evaluate(isError(valueExpr)), false, "isError(%s)", valueExpr)
+    }
+    assertEvaluatesTo(evaluate(isError(nullValue())), false, "isError(null)")
+    assertEvaluatesTo(evaluate(isError(constant(0L))), false, "isError(0L)")
+  }
+}