feat(firestore): Add support for 16MB documents

Author: dlarocque

java-firestore/google-cloud-firestore/src/test/java/com/google/cloud/firestore/it/ITLargeDocumentTest.java

@@ -0,0 +1,160 @@
+/*
+ * Copyright 2026 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.cloud.firestore.it;
+
+import static com.google.cloud.firestore.it.ITQueryTest.map;
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.junit.Assume.assumeTrue;
+
+import com.google.cloud.firestore.CollectionReference;
+import com.google.cloud.firestore.DocumentReference;
+import com.google.cloud.firestore.DocumentSnapshot;
+import com.google.cloud.firestore.FieldPath;
+import com.google.cloud.firestore.FieldValue;
+import com.google.cloud.firestore.FirestoreException;
+import com.google.cloud.firestore.ListenerRegistration;
+import com.google.cloud.firestore.QuerySnapshot;
+import io.grpc.Status;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.TimeUnit;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class ITLargeDocumentTest extends ITBaseTest {
+
+  static boolean runLargeDocTests() {
+    String propertyName = "FIRESTORE_RUN_LARGE_DOC_TESTS";
+    String runLargeTests = System.getProperty(propertyName);
+    if (runLargeTests == null) {
+      runLargeTests = System.getenv(propertyName);
+    }
+    return "YES".equalsIgnoreCase(runLargeTests) || "true".equalsIgnoreCase(runLargeTests);
+  }
+
+  @Before
+  public void checkPreconditions() {
+    assumeTrue(runLargeDocTests());
+    assumeTrue("NIGHTLY".equalsIgnoreCase(getTargetBackend()));
+    assumeTrue(getFirestoreEdition() == FirestoreEdition.ENTERPRISE);
+  }
+
+  @Test
+  public void testReadLargeUnicodeDocument() throws Exception {
+    DocumentReference docRef = firestore.collection("serverSdkTests").document("doc_15_9MB_unicode");
+    DocumentSnapshot snapshot = docRef.get().get();
+    assertTrue(snapshot.exists());
+    String chunk = snapshot.getString("chunk");
+    assertNotNull(chunk);
+    assertEquals(8336178, chunk.length());
+  }
+
+  @Test
+  public void testQueryMultipleLargeDocuments() throws Exception {
+    CollectionReference colRef = firestore.collection("col_large_docs");
+    QuerySnapshot querySnapshot =
+        colRef.whereIn(FieldPath.documentId(), Arrays.asList("doc_a", "doc_b")).get().get();
+    assertEquals(2, querySnapshot.size());
+
+    DocumentSnapshot docA = querySnapshot.getDocuments().get(0);
+    DocumentSnapshot docB = querySnapshot.getDocuments().get(1);
+    assertNotNull(docA.getString("chunk"));
+    assertNotNull(docB.getString("chunk"));
+  }
+
+  @Test
+  public void testWatchStreamInitialization() throws Exception {
+    DocumentReference docRef = firestore.collection("serverSdkTests").document("doc_15_9MB_unicode");
+    CompletableFuture<DocumentSnapshot> snapshotFuture = new CompletableFuture<>();
+    ListenerRegistration registration =
+        docRef.addSnapshotListener(
+            (snapshot, error) -> {
+              if (error != null) {
+                snapshotFuture.completeExceptionally(error);
+              } else if (snapshot != null && snapshot.exists()) {
+                snapshotFuture.complete(snapshot);
+              }
+            });
+
+    try {
+      DocumentSnapshot snapshot = snapshotFuture.get(60, TimeUnit.SECONDS);
+      assertTrue(snapshot.exists());
+      assertNotNull(snapshot.getString("chunk"));
+    } finally {
+      registration.remove();
+    }
+  }
+
+  @Test
+  public void testTransactionReadModifyWrite() throws Exception {
+    DocumentReference docRef = firestore.collection("serverSdkTests").document("doc_15_9MB_unicode");
+    firestore
+        .runTransaction(
+            transaction -> {
+              DocumentSnapshot snapshot = transaction.get(docRef).get();
+              assertTrue(snapshot.exists());
+              transaction.update(docRef, map("transaction_timestamp", FieldValue.serverTimestamp()));
+              return null;
+            })
+        .get(60, TimeUnit.SECONDS);
+  }
+
+  @Test
+  public void testPaginateLargeDocuments() throws Exception {
+    CollectionReference colRef = firestore.collection("col_large_docs");
+    QuerySnapshot firstPage = colRef.orderBy(FieldPath.documentId()).limit(1).get().get();
+    assertEquals(1, firstPage.size());
+    DocumentSnapshot doc1 = firstPage.getDocuments().get(0);
+    assertNotNull(doc1.getString("chunk"));
+
+    QuerySnapshot secondPage =
+        colRef.orderBy(FieldPath.documentId()).startAfter(doc1).limit(1).get().get();
+    assertEquals(1, secondPage.size());
+    DocumentSnapshot doc2 = secondPage.getDocuments().get(0);
+    assertNotNull(doc2.getString("chunk"));
+  }
+
+  @Test
+  public void testOversizedPayloadRejection() {
+    DocumentReference docRef = firestore.collection("serverSdkTests").document("temp_oversized_doc");
+    int targetBytes = 16 * 1024 * 1024 + 102400;
+    StringBuilder builder = new StringBuilder(targetBytes);
+    for (int i = 0; i < targetBytes; i++) {
+      builder.append('a');
+    }
+    String largePayload = builder.toString();
+    Map<String, Object> data = new HashMap<>();
+    data.put("chunk", largePayload);
+
+    try {
+      docRef.set(data).get(60, TimeUnit.SECONDS);
+      fail("Setting a document exceeding the 16MB limit should fail.");
+    } catch (Exception e) {
+      Throwable cause = e.getCause();
+      assertTrue(cause instanceof com.google.api.gax.rpc.InvalidArgumentException);
+    }
+  }
+}