add integration test for raising initial snapshot from cached empty result

Author: milaGGL

firebase-firestore/src/androidTest/java/com/google/firebase/firestore/QueryTest.java

@@ -550,6 +550,50 @@ public void testQueriesFireFromCacheWhenOffline() {
     listener.remove();
   }
 
+  @Test
+  public void testQueriesCanRaiseInitialSnapshotFromCachedEmptyResults() {
+    CollectionReference collectionReference = testCollection();
+
+    // Populate the cache with empty query result.
+    QuerySnapshot querySnapshotA = waitFor(collectionReference.get());
+    assertFalse(querySnapshotA.getMetadata().isFromCache());
+    assertEquals(asList(), querySnapshotToValues(querySnapshotA));
+
+    // Add a snapshot listener whose first event should be raised from cache.
+    EventAccumulator<QuerySnapshot> accum = new EventAccumulator<>();
+    ListenerRegistration listenerRegistration =
+        collectionReference.addSnapshotListener(accum.listener());
+    QuerySnapshot querySnapshotB = accum.await();
+    assertTrue(querySnapshotB.getMetadata().isFromCache());
+    assertEquals(asList(), querySnapshotToValues(querySnapshotB));
+
+    listenerRegistration.remove();
+  }
+
+  @Test
+  public void testQueriesCanRaiseInitialSnapshotFromEmptyDueToDeleteCachedResults() {
+    Map<String, Map<String, Object>> testDocs = map("a", map("foo", 1L));
+    CollectionReference collectionReference = testCollectionWithDocs(testDocs);
+    // Populate the cache with single document.
+    QuerySnapshot querySnapshotA = waitFor(collectionReference.get());
+    assertFalse(querySnapshotA.getMetadata().isFromCache());
+    assertEquals(asList(testDocs.get("a")), querySnapshotToValues(querySnapshotA));
+
+    // delete the document, make cached result empty.
+    DocumentReference docRef = collectionReference.document("a");
+    waitFor(docRef.delete());
+
+    // Add a snapshot listener whose first event should be raised from cache.
+    EventAccumulator<QuerySnapshot> accum = new EventAccumulator<>();
+    ListenerRegistration listenerRegistration =
+        collectionReference.addSnapshotListener(accum.listener());
+    QuerySnapshot querySnapshotB = accum.await();
+    assertTrue(querySnapshotB.getMetadata().isFromCache());
+    assertEquals(asList(), querySnapshotToValues(querySnapshotB));
+
+    listenerRegistration.remove();
+  }
+
   @Test
   public void testQueriesCanUseNotEqualFilters() {
     // These documents are ordered by value in "zip" since the notEquals filter is an inequality,

firebase-firestore/src/main/java/com/google/firebase/firestore/core/SyncEngine.java

@@ -225,10 +225,11 @@ private ViewSnapshot initializeViewAndComputeSnapshot(
     if (this.queriesByTarget.get(targetId) != null) {
       Query mirrorQuery = this.queriesByTarget.get(targetId).get(0);
       currentTargetSyncState = this.queryViewsByQuery.get(mirrorQuery).getView().getSyncState();
-      synthesizedCurrentChange =
-          TargetChange.createSynthesizedTargetChangeForCurrentChange(
-              currentTargetSyncState == SyncState.SYNCED, resumeToken);
     }
+    ;
+    synthesizedCurrentChange =
+        TargetChange.createSynthesizedTargetChangeForCurrentChange(
+            currentTargetSyncState == SyncState.SYNCED, resumeToken);
 
     // TODO(wuandy): Investigate if we can extract the logic of view change computation and
     // update tracked limbo in one place, and have both emitNewSnapsAndNotifyLocalStore

firebase-firestore/src/main/java/com/google/firebase/firestore/core/ViewSnapshot.java

@@ -174,6 +174,7 @@ public int hashCode() {
     result = 31 * result + (isFromCache ? 1 : 0);
     result = 31 * result + (didSyncStateChange ? 1 : 0);
     result = 31 * result + (excludesMetadataChanges ? 1 : 0);
+    result = 31 * result + (hasCachedResults ? 1 : 0);
     return result;
   }
 

firebase-firestore/src/roboUtil/java/com/google/firebase/firestore/TestUtil.java

@@ -83,7 +83,8 @@ public static QuerySnapshot querySnapshot(
       Map<String, ObjectValue> oldDocs,
       Map<String, ObjectValue> docsToAdd,
       boolean hasPendingWrites,
-      boolean isFromCache) {
+      boolean isFromCache,
+      boolean hasCachedResults) {
     DocumentSet oldDocuments = docSet(Document.KEY_COMPARATOR);
     ImmutableSortedSet<DocumentKey> mutatedKeys = DocumentKey.emptyKeySet();
     for (Map.Entry<String, ObjectValue> pair : oldDocs.entrySet()) {
@@ -117,7 +118,7 @@ public static QuerySnapshot querySnapshot(
             mutatedKeys,
             /* didSyncStateChange= */ true,
             /* excludesMetadataChanges= */ false,
-            /* hasCachedResults= */ false);
+            hasCachedResults);
     return new QuerySnapshot(query(path), viewSnapshot, FIRESTORE);
   }
 

firebase-firestore/src/test/java/com/google/firebase/firestore/QuerySnapshotTest.java

@@ -56,21 +56,26 @@ public void testEquals() {
     ObjectValue firstValue = wrapObject("a", 1);
     ObjectValue secondValue = wrapObject("b", 1);
 
-    QuerySnapshot foo = TestUtil.querySnapshot("foo", map(), map("a", firstValue), true, false);
-    QuerySnapshot fooDup = TestUtil.querySnapshot("foo", map(), map("a", firstValue), true, false);
+    QuerySnapshot foo =
+        TestUtil.querySnapshot("foo", map(), map("a", firstValue), true, false, false);
+    QuerySnapshot fooDup =
+        TestUtil.querySnapshot("foo", map(), map("a", firstValue), true, false, false);
     QuerySnapshot differentPath =
-        TestUtil.querySnapshot("bar", map(), map("a", firstValue), true, false);
+        TestUtil.querySnapshot("bar", map(), map("a", firstValue), true, false, false);
     QuerySnapshot differentDoc =
-        TestUtil.querySnapshot("foo", map(), map("a", secondValue), true, false);
+        TestUtil.querySnapshot("foo", map(), map("a", secondValue), true, false, false);
     QuerySnapshot noPendingWrites =
-        TestUtil.querySnapshot("foo", map(), map("a", firstValue), false, false);
+        TestUtil.querySnapshot("foo", map(), map("a", firstValue), false, false, false);
     QuerySnapshot fromCache =
-        TestUtil.querySnapshot("foo", map(), map("a", firstValue), true, true);
+        TestUtil.querySnapshot("foo", map(), map("a", firstValue), true, true, false);
+    QuerySnapshot hasCachedResults =
+        TestUtil.querySnapshot("foo", map(), map("a", firstValue), true, false, true);
     assertEquals(foo, fooDup);
     assertNotEquals(foo, differentPath);
     assertNotEquals(foo, differentDoc);
     assertNotEquals(foo, noPendingWrites);
     assertNotEquals(foo, fromCache);
+    assertNotEquals(foo, hasCachedResults);
 
     // Note: `foo` and `differentDoc` have the same hash code since we no longer take document
     // contents into account.
@@ -88,7 +93,8 @@ public void testToObjects() {
 
     ObjectValue objectData =
         ObjectValue.fromMap(map("timestamp", ServerTimestamps.valueOf(Timestamp.now(), null)));
-    QuerySnapshot foo = TestUtil.querySnapshot("foo", map(), map("a", objectData), true, false);
+    QuerySnapshot foo =
+        TestUtil.querySnapshot("foo", map(), map("a", objectData), true, false, false);
 
     List<POJO> docs = foo.toObjects(POJO.class);
     assertEquals(1, docs.size());