Test Harness for gRPC Integration Test of full Firestore stack (#6043)

tom-andersen · web-flow · commit 58540de24c9b · 2024-07-03T20:02:25.000-04:00
A single test of existing Write stream handshake.

- Test is written using new ComponentProvider to mock out gRPC layer.
- Test uses `FirebaseFirestore` instance to write document data.
- Server integration on the gRPC layer is faked and verified, such that
each proto exchanged with server is written into the test.

This test harness will be used to test cache clearing semantics in
future PR.
diff --git a/buildSrc/src/main/java/com/google/firebase/gradle/plugins/ci/device/FirebaseTestServer.java b/buildSrc/src/main/java/com/google/firebase/gradle/plugins/ci/device/FirebaseTestServer.java
@@ -78,7 +78,7 @@ public void uploadApks(String variantName, File testApk, File testedApk) {
         "--type=instrumentation",
         "--app=" + testedApkPath,
         "--test=" + testApk,
-        "--timeout=30m",
+        "--timeout=45m",
         "--use-orchestrator",
         "--no-auto-google-login",
         "--no-record-video",
diff --git a/firebase-firestore/firebase-firestore.gradle b/firebase-firestore/firebase-firestore.gradle
@@ -24,7 +24,7 @@ firebaseLibrary {
     publishSources = true
     testLab {
         enabled = true
-        timeout = '30m'
+        timeout = '45m'
     }
 }
 
diff --git a/firebase-firestore/src/androidTest/java/com/google/firebase/firestore/CompositeIndexQueryTest.java b/firebase-firestore/src/androidTest/java/com/google/firebase/firestore/CompositeIndexQueryTest.java
@@ -24,6 +24,7 @@
 import static com.google.firebase.firestore.Filter.notEqualTo;
 import static com.google.firebase.firestore.Filter.notInArray;
 import static com.google.firebase.firestore.Filter.or;
+import static com.google.firebase.firestore.testutil.CompositeIndexTestHelper.COMPOSITE_INDEX_TEST_COLLECTION;
 import static com.google.firebase.firestore.testutil.IntegrationTestUtil.nullList;
 import static com.google.firebase.firestore.testutil.IntegrationTestUtil.testFirestore;
 import static com.google.firebase.firestore.testutil.IntegrationTestUtil.waitFor;
@@ -113,7 +114,6 @@ public void testOrQueriesWithCompositeIndexes() {
   @Test
   public void testCanRunAggregateCollectionGroupQuery() {
     CompositeIndexTestHelper testHelper = new CompositeIndexTestHelper();
-    String collectionGroup = testHelper.withTestCollection().getId();
 
     FirebaseFirestore db = testFirestore();
 
@@ -134,15 +134,15 @@ public void testCanRunAggregateCollectionGroupQuery() {
     WriteBatch batch = db.batch();
     for (String path : docPaths) {
       batch.set(
-          db.document(path.replace("${collectionGroup}", collectionGroup)),
+          db.document(path.replace("${collectionGroup}", COMPOSITE_INDEX_TEST_COLLECTION)),
           testHelper.addTestSpecificFieldsToDoc(map("a", 2)));
     }
     waitFor(batch.commit());
 
     AggregateQuerySnapshot snapshot =
         waitFor(
             testHelper
-                .query(db.collectionGroup(collectionGroup))
+                .query(db.collectionGroup(COMPOSITE_INDEX_TEST_COLLECTION))
                 .aggregate(AggregateField.count(), sum("a"), average("a"))
                 .get(AggregateSource.SERVER));
     assertEquals(
diff --git a/firebase-firestore/src/androidTest/java/com/google/firebase/firestore/testutil/CompositeIndexTestHelper.java b/firebase-firestore/src/androidTest/java/com/google/firebase/firestore/testutil/CompositeIndexTestHelper.java
@@ -17,6 +17,7 @@
 import static com.google.firebase.firestore.testutil.IntegrationTestUtil.checkOnlineAndOfflineResultsMatch;
 import static com.google.firebase.firestore.testutil.IntegrationTestUtil.querySnapshotToIds;
 import static com.google.firebase.firestore.testutil.IntegrationTestUtil.testFirestore;
+import static com.google.firebase.firestore.testutil.IntegrationTestUtil.testInMemoryFirestore;
 import static com.google.firebase.firestore.testutil.IntegrationTestUtil.waitFor;
 import static com.google.firebase.firestore.testutil.IntegrationTestUtil.writeAllDocs;
 import static com.google.firebase.firestore.util.Util.autoId;
@@ -53,7 +54,7 @@ public class CompositeIndexTestHelper {
   private final String testId;
   private static final String TEST_ID_FIELD = "testId";
   private static final String TTL_FIELD = "expireAt";
-  private static final String COMPOSITE_INDEX_TEST_COLLECTION = "composite-index-test-collection";
+  public static final String COMPOSITE_INDEX_TEST_COLLECTION = "composite-index-test-collection";
 
   // Creates a new instance of the CompositeIndexTestHelper class, with a unique test
   // identifier for data isolation.
@@ -69,7 +70,7 @@ public CollectionReference withTestCollection() {
   // Runs a test with specified documents in the COMPOSITE_INDEX_TEST_COLLECTION.
   @NonNull
   public CollectionReference withTestDocs(@NonNull Map<String, Map<String, Object>> docs) {
-    CollectionReference writer = withTestCollection();
+    CollectionReference writer = testInMemoryFirestore().collection(COMPOSITE_INDEX_TEST_COLLECTION);
     writeAllDocs(writer, prepareTestDocuments(docs));
     CollectionReference reader = testFirestore().collection(writer.getPath());
     return reader;
diff --git a/firebase-firestore/src/androidTest/java/com/google/firebase/firestore/testutil/IntegrationTestUtil.java b/firebase-firestore/src/androidTest/java/com/google/firebase/firestore/testutil/IntegrationTestUtil.java
@@ -124,7 +124,6 @@ public enum TargetBackend {
   private static final FirestoreProvider provider = new FirestoreProvider();
 
   private static boolean strictModeEnabled = false;
-  private static boolean backendPrimed = false;
 
   // FirebaseOptions needed to create a test FirebaseApp.
   private static final FirebaseOptions OPTIONS =
diff --git a/firebase-firestore/src/test/java/com/google/firebase/firestore/FirebaseFirestoreIntegrationTestFactory.java b/firebase-firestore/src/test/java/com/google/firebase/firestore/FirebaseFirestoreIntegrationTestFactory.java
@@ -0,0 +1,164 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+//
+// You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.firebase.firestore;
+
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import androidx.test.core.app.ApplicationProvider;
+
+import com.google.android.gms.tasks.Task;
+import com.google.android.gms.tasks.TaskCompletionSource;
+import com.google.android.gms.tasks.Tasks;
+import com.google.firebase.firestore.core.ComponentProvider;
+import com.google.firebase.firestore.integration.AsyncTaskAccumulator;
+import com.google.firebase.firestore.model.DatabaseId;
+import com.google.firebase.firestore.remote.GrpcCallProvider;
+import com.google.firebase.firestore.remote.RemoteComponenetProvider;
+import com.google.firebase.firestore.testutil.EmptyAppCheckTokenProvider;
+import com.google.firebase.firestore.testutil.EmptyCredentialsProvider;
+import com.google.firebase.firestore.util.AsyncQueue;
+import com.google.firestore.v1.FirestoreGrpc;
+import com.google.firestore.v1.ListenRequest;
+import com.google.firestore.v1.ListenResponse;
+import com.google.firestore.v1.WriteRequest;
+import com.google.firestore.v1.WriteResponse;
+
+import com.google.firebase.firestore.integration.TestClientCall;
+
+/**
+ * Factory for producing FirebaseFirestore instances that has mocked gRPC layer.
+ *
+ * <ol>
+ *  <li>Response protos from server can be faked.
+ *  <li>Request protos from SDK can be verified.
+ * </ol>
+ *
+ * <p>
+ * The FirebaseFirestoreIntegrationTestFactory is located in this package to gain package-private
+ * access to FirebaseFirestore methods.
+ */
+public final class FirebaseFirestoreIntegrationTestFactory {
+
+    /**
+     * Everytime the `componentProviderFactory` on FirebaseFirestore is run, a new instance is added.
+     */
+    public final AsyncTaskAccumulator<Instance> instances = new AsyncTaskAccumulator<>();
+
+    /**
+     * Instance of Firestore components.
+     */
+    public static class Instance {
+
+        /** Instance of ComponentProvider */
+        public final ComponentProvider componentProvider;
+
+        /** Every listen stream created is captured here. */
+        private final AsyncTaskAccumulator<TestClientCall<ListenRequest, ListenResponse>> listens = new AsyncTaskAccumulator<>();
+
+        /** Every write stream created is captured here. */
+        private final AsyncTaskAccumulator<TestClientCall<WriteRequest, WriteResponse>> writes = new AsyncTaskAccumulator<>();
+
+        private Instance(ComponentProvider componentProvider) {
+            this.componentProvider = componentProvider;
+        }
+
+        /**
+         * Queues work on AsyncQueue. This is required when faking responses from server since they
+         * must be handled through the AsyncQueue of the FirestoreClient.
+         */
+        public Task<Void> enqueue(Runnable runnable) {
+            return configuration.asyncQueue.enqueue(runnable);
+        }
+
+        /**
+         * Configuration passed to `ComponentProvider`
+         *
+         * <p>
+         * This is never null because `Task<Instance>` completes after initialization. The
+         * `FirebaseFirestoreIntegrationTestFactory` will set `Instance.configuration` from within
+         * the ComponentProvider override.
+         */
+        private ComponentProvider.Configuration configuration;
+
+        /** Every listen stream created */
+        public Task<TestClientCall<ListenRequest, ListenResponse>> getListenClient(int i) {
+            return listens.get(i);
+        }
+
+        /** Every write stream created */
+        public Task<TestClientCall<WriteRequest, WriteResponse>> getWriteClient(int i) {
+            return writes.get(i);
+        }
+
+    }
+
+    /**
+     * The FirebaseFirestore instance.
+     */
+    public final FirebaseFirestore firestore;
+
+    /**
+     * Mockito Mock of `FirebaseFirestore.InstanceRegistry` that was passed into FirebaseFirestore
+     * constructor.
+     */
+    public final FirebaseFirestore.InstanceRegistry instanceRegistry = mock(FirebaseFirestore.InstanceRegistry.class);
+
+    public FirebaseFirestoreIntegrationTestFactory(DatabaseId databaseId) {
+        firestore = new FirebaseFirestore(
+                ApplicationProvider.getApplicationContext(),
+                databaseId,
+                "k",
+                new EmptyCredentialsProvider(),
+                new EmptyAppCheckTokenProvider(),
+                new AsyncQueue(),
+                this::componentProvider,
+                null,
+                instanceRegistry,
+                null
+        );
+    }
+
+    public void useMemoryCache() {
+        FirebaseFirestoreSettings.Builder builder = new FirebaseFirestoreSettings.Builder(firestore.getFirestoreSettings());
+        builder.setLocalCacheSettings(MemoryCacheSettings.newBuilder().build());
+        firestore.setFirestoreSettings(builder.build());
+    }
+
+    private GrpcCallProvider mockGrpcCallProvider(Instance instance) {
+        GrpcCallProvider mockGrpcCallProvider = mock(GrpcCallProvider.class);
+        when(mockGrpcCallProvider.createClientCall(eq(FirestoreGrpc.getListenMethod())))
+                .thenAnswer(invocation -> Tasks.forResult(new TestClientCall<>(instance.listens.next())));
+        when(mockGrpcCallProvider.createClientCall(eq(FirestoreGrpc.getWriteMethod())))
+                .thenAnswer(invocation -> Tasks.forResult(new TestClientCall<>(instance.writes.next())));
+        return mockGrpcCallProvider;
+    }
+
+    private ComponentProvider componentProvider(FirebaseFirestoreSettings settings) {
+        TaskCompletionSource<Instance> next = instances.next();
+        ComponentProvider componentProvider = ComponentProvider.defaultFactory(settings);
+        Instance instance = new Instance(componentProvider);
+        componentProvider.setRemoteProvider(new RemoteComponenetProvider() {
+            @Override
+            protected GrpcCallProvider createGrpcCallProvider(ComponentProvider.Configuration configuration) {
+                instance.configuration = configuration;
+                next.setResult(instance);
+                return mockGrpcCallProvider(instance);
+            }
+        });
+        return componentProvider;
+    }
+}
diff --git a/firebase-firestore/src/test/java/com/google/firebase/firestore/integration/AsyncTaskAccumulator.java b/firebase-firestore/src/test/java/com/google/firebase/firestore/integration/AsyncTaskAccumulator.java
@@ -0,0 +1,124 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+//
+// You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+package com.google.firebase.firestore.integration;
+
+import androidx.annotation.NonNull;
+
+import com.google.android.gms.tasks.Task;
+import com.google.android.gms.tasks.TaskCompletionSource;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.NoSuchElementException;
+
+
+/**
+ * Collects asynchronous `onResult` and `onException` callback invocations.
+ *
+ * <p> As part of a test, a callback can be asynchronously invoked many times. This class retains
+ * all callback invocations as a List of Task. The test code can await a future callback.
+ *
+ * <p> Just like a stream, no more results are expected after an exception.
+ */
+public class AsyncTaskAccumulator<T> implements Iterable<Task<T>> {
+
+    private int eventCount;
+    private List<TaskCompletionSource<T>> events;
+
+    public AsyncTaskAccumulator() {
+        eventCount = 0;
+        events = new ArrayList<>();
+    }
+
+    /**
+     * Callback for next `onResult` or `onException`. Calling this method repeatedly will
+     * provide callbacks further into the future. Each callback should only be exactly once.
+     */
+    public synchronized TaskCompletionSource<T> next() {
+        return computeIfAbsentIndex(eventCount++);
+    }
+
+    /**
+     * Callback that can be invoked as part of test code.
+     */
+    public void onResult(T result) {
+        next().setResult(result);
+    }
+
+    /**
+     * Callback that can be invoked as part of test code.
+     */
+    public void onException(Exception e) {
+        next().setException(e);
+    }
+
+    private TaskCompletionSource<T> computeIfAbsentIndex(int i) {
+        while (events.size() <= i) {
+            events.add(new TaskCompletionSource<>());
+        }
+        return events.get(i);
+    }
+
+    /**
+     * Get task that completes when result arrives.
+     *
+     * @param index 0 indexed arrival sequence of results.
+     * @return Task.
+     */
+    @NonNull
+    public synchronized Task<T> get(int index) {
+        return computeIfAbsentIndex(index).getTask();
+    }
+
+    /**
+     * Iterates over results.
+     * <p>
+     * The Iterator is thread safe.
+     * Iteration will stop upon task that is failed, cancelled or incomplete.
+     * <p>
+     * A loop that waits for task to complete before getting next task will continue to iterate
+     * indefinitely. Attempting to iterate past a task that is not yet successful will throw
+     * {#code NoSuchElementException} and {@code #hasNext()} will be false. In this way, iteration
+     * in nonblocking. Last element will be failed, cancelled or awaiting result.
+     *
+     * @return Iterator of Tasks that complete.
+     */
+    @NonNull
+    @Override
+    public Iterator<Task<T>> iterator() {
+        return new Iterator<Task<T>>() {
+
+            private int i = -1;
+            private Task<T> current;
+
+            @Override
+            public synchronized boolean hasNext() {
+                // We always return first, and continue to return tasks so long as previous
+                // is successful. A task that hasn't completed, will also mark the end of
+                // iteration.
+                return i < 0 || current.isSuccessful();
+            }
+
+            @Override
+            public synchronized Task<T> next() {
+                if (!hasNext()) {
+                    throw new NoSuchElementException();
+                }
+                i++;
+                return current = get(i);
+            }
+        };
+    }
+}
diff --git a/firebase-firestore/src/test/java/com/google/firebase/firestore/integration/FirebaseFirestoreTest.java b/firebase-firestore/src/test/java/com/google/firebase/firestore/integration/FirebaseFirestoreTest.java
diff --git a/firebase-firestore/src/test/java/com/google/firebase/firestore/integration/TestClientCall.java b/firebase-firestore/src/test/java/com/google/firebase/firestore/integration/TestClientCall.java

Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ firebaseLibrary {`
`24`	`24`	`publishSources = true`
`25`	`25`	`testLab {`
`26`	`26`	`enabled = true`
`27`		`- timeout = '30m'`
	`27`	`+ timeout = '45m'`
`28`	`28`	`}`
`29`	`29`	`}`
`30`	`30`