refactor test

Author: alkatrivedi

src/transaction.ts

@@ -390,7 +390,8 @@ export class Snapshot extends EventEmitter {
     if (
       this._latestPreCommitToken === null ||
       this._latestPreCommitToken === undefined ||
-      this._latestPreCommitToken!.seqNum! < resp.precommitToken!.seqNum!
+      (resp.precommitToken &&
+        this._latestPreCommitToken!.seqNum! < resp.precommitToken!.seqNum!)
     ) {
       this._latestPreCommitToken = resp.precommitToken;
     }

system-test/spanner.ts

@@ -9241,40 +9241,6 @@ describe('Spanner', () => {
           // wait for both the transactions to complete their execution
           await Promise.all(promises);
         });
-
-        it('POSTGRESQL should insert and commit transactions when running parallely', async () => {
-          const promises: Promise<void>[] = [];
-          let resolvePromise;
-          const commitPromise = new Promise(
-            resolve => (resolvePromise = resolve),
-          );
-          const sync = {
-            target: 2, // both the transactions to be ready
-            count: 0, // 0 transactions are ready so far
-            promise: commitPromise, // the promise both the transactions wait at
-            resolveCommitPromise: () => resolvePromise(), // the function to resolve the commit promise
-          };
-          // run the transactions in parallel
-          promises.push(
-            insertAndCommitTransaction(
-              PG_DATABASE,
-              sync,
-              postgreSqlTable,
-              'k1102',
-            ),
-          );
-          promises.push(
-            insertAndCommitTransaction(
-              PG_DATABASE,
-              sync,
-              postgreSqlTable,
-              'k1103',
-            ),
-          );
-
-          // wait for both the transactions to complete their execution
-          await Promise.all(promises);
-        });
       });
 
       const rollbackTransaction = (done, database) => {

test/mockserver/mockspanner.ts

@@ -321,6 +321,7 @@ export class MockSpanner {
   private metadata: Metadata[] = [];
   private frozen = 0;
   private sessionCounter = 0;
+  private _seqNum = 0;
   private sessions: Map<string, protobuf.Session> = new Map<
     string,
     protobuf.Session
@@ -371,6 +372,7 @@ export class MockSpanner {
     this.partitionRead = this.partitionRead.bind(this);
     this.batchWrite = this.batchWrite.bind(this);
     this.mutationOnly = false;
+    this._seqNum = 1;
   }
 
   /**
@@ -704,7 +706,7 @@ export class MockSpanner {
             const precommitToken = session?.multiplexed
               ? protobuf.MultiplexedSessionPrecommitToken.create({
                   precommitToken: Buffer.from('mock-precommit-token'),
-                  seqNum: randomInt(1, 1000),
+                  seqNum: this._seqNum++,
                 })
               : null;
             if (txn instanceof Error) {
@@ -816,6 +818,7 @@ export class MockSpanner {
       const partial = protobuf.PartialResultSet.create({
         resumeToken: Buffer.from(token),
         values: [],
+        precommitToken: resultSet.precommitToken,
       });
       for (
         let row = i;
@@ -1022,7 +1025,7 @@ export class MockSpanner {
             const precommitToken = session?.multiplexed
               ? protobuf.MultiplexedSessionPrecommitToken.create({
                   precommitToken: Buffer.from('mock-precommit-token'),
-                  seqNum: randomInt(1, 1000),
+                  seqNum: this._seqNum++,
                 })
               : null;
             if (txn instanceof Error) {
@@ -1277,7 +1280,7 @@ export class MockSpanner {
       this.mutationOnly && session.multiplexed && options?.readWrite
         ? {
             precommitToken: Buffer.from('mock-precommit-token'),
-            seqNum: randomInt(1, 1000),
+            seqNum: this._seqNum++,
           }
         : null;
     const transaction = protobuf.Transaction.create({

test/spanner.ts

@@ -4671,7 +4671,7 @@ describe('Spanner with mock server', () => {
             MultiplexedSessionRetry: 'precommitToken',
             precommitToken: {
               precommitToken: fakeRetryToken,
-              seqNum: 1,
+              seqNum: 100,
             },
             commitTimestamp: mock.now(),
           };
@@ -4701,7 +4701,7 @@ describe('Spanner with mock server', () => {
             await tx!.run(selectSql);
 
             // perform mutations
-            await tx.upsert('foo', [
+            tx.upsert('foo', [
               {id: 1, name: 'One'},
               {id: 2, name: 'Two'},
             ]);
@@ -4715,13 +4715,7 @@ describe('Spanner with mock server', () => {
               2,
               'The mock commit method should have been called exactly twice.',
             );
-            const firstRequest = capturedCommitRequests[0];
-            // assert that during the first request to commit
-            // the precommitToken was missing
-            assert.ok(
-              !firstRequest.precommitToken,
-              'The first commit request should not have a precommitToken.',
-            );
+
             const secondRequest = capturedCommitRequests[1];
             // assert that during the second request to commit
             // the precommitToken was present
@@ -4740,6 +4734,7 @@ describe('Spanner with mock server', () => {
         async function insertAndCommit() {
           const database = newTestDatabase();
           await database.runTransactionAsync(async tx => {
+            await tx.run(selectSql);
             tx.upsert('foo', [
               {id: 1, name: 'One'},
               {id: 2, name: 'Two'},
@@ -4785,12 +4780,6 @@ describe('Spanner with mock server', () => {
             commitRequest[0].precommitToken.precommitToken,
             commitRequest[1].precommitToken.precommitToken,
           );
-
-          // assert that seqNum is different in both the commit request
-          assert.notEqual(
-            commitRequest[0].precommitToken.seqNum,
-            commitRequest[1].precommitToken.seqNum,
-          );
         });
       });
     });