fix: add BulkWriter integration tests, java backport changes, delete fix

dev/src/write-batch.ts

@@ -575,12 +575,33 @@ export class WriteBatch implements firestore.WriteBatch {
       api.BatchWriteResponse
     >('batchWrite', request, tag);
 
-    return (response.writeResults || []).map((result, i) => {
+    const writeResults = response.writeResults || [];
+    let latestTimestamp = Timestamp.fromMillis(0);
+    writeResults.forEach(result => {
+      if (
+        result.updateTime &&
+        Timestamp.fromProto(result.updateTime) > latestTimestamp
+      ) {
+        latestTimestamp = Timestamp.fromProto(result.updateTime);
+      }
+    });
+
+    return writeResults.map((result, i) => {
       const status = response.status[i];
       const error = new GoogleError(status.message || undefined);
       error.code = status.code as Status;
+
+      // Since delete operations currently do not have write times, use the
+      // latest update time for deletes, or Timestamp(0,0) if the entire batch
+      // consists of deletes.
+      const isSuccessfulDelete =
+        result.updateTime === null && error.code === Status.OK;
       return new BatchWriteResult(
-        result.updateTime ? Timestamp.fromProto(result.updateTime) : null,
+        isSuccessfulDelete
+          ? latestTimestamp
+          : result.updateTime
+          ? Timestamp.fromProto(result.updateTime)
+          : null,
         error
       );
     });

dev/system-test/firestore.ts

@@ -44,6 +44,7 @@ import {
   verifyInstance,
 } from '../test/util/helpers';
 import IBundleElement = firestore.IBundleElement;
+import {BulkWriter} from '../src/bulk-writer';
 
 use(chaiAsPromised);
 
@@ -2329,23 +2330,91 @@ describe('QuerySnapshot class', () => {
 describe('BulkWriter class', () => {
   let firestore: Firestore;
   let randomCol: CollectionReference;
+  let writer: BulkWriter;
 
   beforeEach(() => {
     firestore = new Firestore({});
+    writer = firestore._bulkWriter();
     randomCol = getTestRoot(firestore);
   });
 
   afterEach(() => verifyInstance(firestore));
 
-  // TODO(BulkWriter): Enable this test once protos are public.
-  it.skip('can terminate once BulkWriter is closed', async () => {
+  it('has create() method', async () => {
+    const ref = randomCol.doc('doc1');
+    const promise = writer.create(ref, {foo: 'bar'});
+    await writer.close();
+    const result = await ref.get();
+    expect(result.data()).to.deep.equal({foo: 'bar'});
+    const writeTime = (await promise).writeTime;
+    expect(writeTime).to.not.be.null;
+  });
+
+  it('has set() method', async () => {
+    const ref = randomCol.doc('doc1');
+    const promise = writer.set(ref, {foo: 'bar'});
+    await writer.close();
+    const result = await ref.get();
+    expect(result.data()).to.deep.equal({foo: 'bar'});
+    const writeTime = (await promise).writeTime;
+    expect(writeTime).to.not.be.null;
+  });
+
+  it('has update() method', async () => {
+    const ref = randomCol.doc('doc1');
+    await ref.set({foo: 'bar'});
+    const promise = writer.update(ref, {foo: 'bar2'});
+    await writer.close();
+    const result = await ref.get();
+    expect(result.data()).to.deep.equal({foo: 'bar2'});
+    const writeTime = (await promise).writeTime;
+    expect(writeTime).to.not.be.null;
+  });
+
+  it('has delete() method', async () => {
+    const ref = randomCol.doc('doc1');
+    await ref.set({foo: 'bar'});
+    const promise = writer.delete(ref);
+    await writer.close();
+    const result = await ref.get();
+    expect(result.exists).to.be.false;
+    // TODO(b/158502664): Remove this check once we can get write times.
+    const deleteResult = await promise;
+    expect(deleteResult.writeTime).to.deep.equal(new Timestamp(0, 0));
+  });
+
+  // TODO(b/158502664): Remove this test once we can get write times.
+  it('delete uses the latest update time of other operations', async () => {
+    const ref = randomCol.doc('doc1');
+    const ref2 = randomCol.doc('doc2');
+    await ref.set({foo: 'bar'});
+    await ref2.set({foo: 'bar'});
+    // Update a different doc so that the writes are sent in the same batch.
+    const updatePromise = writer.update(randomCol.doc('doc2'), {foo: 'bar1'});
+    const deletePromise = writer.delete(ref);
+    await writer.close();
+    const deleteResult = await deletePromise;
+    const updateResult = await updatePromise;
+    expect(deleteResult.writeTime).to.deep.equal(updateResult.writeTime);
+  });
+
+  it('can terminate once BulkWriter is closed', async () => {
     const ref = randomCol.doc('doc1');
-    const writer = firestore._bulkWriter();
     writer.set(ref, {foo: 'bar'});
-    writer.set(ref, {foo: 'bar2'});
     await writer.close();
     return firestore.terminate();
   });
+
+  it('writes to the same document in order', async () => {
+    const ref = randomCol.doc('doc1');
+    await ref.set({foo: 'bar0'});
+    writer.set(ref, {foo: 'bar1'});
+    writer.set(ref, {foo: 'bar2'});
+    writer.set(ref, {foo: 'bar3'});
+    await writer.flush();
+    const res = await ref.get();
+    expect(res.data()).to.deep.equal({foo: 'bar3'});
+  });
 });
 
 describe('Client initialization', () => {

dev/test/bulk-writer.ts

@@ -97,21 +97,21 @@ describe('BulkWriter', () => {
     };
   }
 
-  function successResponse(seconds: number): api.IBatchWriteResponse {
+  function successResponse(updateTimeSeconds: number): api.IBatchWriteResponse {
     return {
       writeResults: [
         {
           updateTime: {
             nanos: 0,
-            seconds,
+            seconds: updateTimeSeconds,
           },
         },
       ],
       status: [{code: Status.OK}],
     };
   }
 
-  function failResponse(): api.IBatchWriteResponse {
+  function failedResponse(): api.IBatchWriteResponse {
     return {
       writeResults: [
         {
@@ -254,7 +254,7 @@ describe('BulkWriter', () => {
     const bulkWriter = await instantiateInstance([
       {
         request: createRequest([setOp('doc', 'bar')]),
-        response: failResponse(),
+        response: failedResponse(),
       },
     ]);
 
@@ -332,11 +332,11 @@ describe('BulkWriter', () => {
     const bulkWriter = await instantiateInstance([
       {
         request: createRequest([setOp('doc', 'bar')]),
-        response: successResponse(0),
+        response: successResponse(1),
       },
       {
         request: createRequest([updateOp('doc', 'bar1')]),
-        response: successResponse(1),
+        response: successResponse(2),
       },
     ]);
 
@@ -355,7 +355,7 @@ describe('BulkWriter', () => {
     const bulkWriter = await instantiateInstance([
       {
         request: createRequest([setOp('doc1', 'bar'), updateOp('doc2', 'bar')]),
-        response: mergeResponses([successResponse(0), successResponse(1)]),
+        response: mergeResponses([successResponse(1), successResponse(2)]),
       },
     ]);
 
@@ -404,7 +404,7 @@ describe('BulkWriter', () => {
     const bulkWriter = await instantiateInstance([
       {
         request: createRequest([setOp('doc', 'bar')]),
-        response: successResponse(0),
+        response: successResponse(1),
       },
       {
         request: createRequest([
@@ -447,9 +447,9 @@ describe('BulkWriter', () => {
           createOp('doc3', 'bar'),
         ]),
         response: mergeResponses([
-          successResponse(0),
           successResponse(1),
           successResponse(2),
+          successResponse(3),
         ]),
       },
       {