Add an integration test

The integration test looks at the data from the snapshot read time for transactions and ensures that the read has no data thereby exercising the read time parameter.

system-test/datastore.ts

@@ -1584,6 +1584,27 @@ describe('Datastore', () => {
     });
   });
   describe('transactions', () => {
+    before(async () => {
+      // This 'sleep' function is used to ensure that when data is saved to datastore,
+      // the time on the server is far enough ahead to be sure to be later than timeBeforeDataCreation
+      // so that when we read at timeBeforeDataCreation we get a snapshot of data before the save.
+      const key = datastore.key(['Company', 'Google']);
+      function sleep(ms: number) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+      }
+      // Save for a key so that a read time can be accessed for snapshot reads.
+      const emptyData = {
+        key,
+        data: {},
+      };
+      await datastore.save(emptyData);
+      timeBeforeDataCreation = await getReadTime([
+        {kind: 'Company', name: 'Google'},
+      ]);
+      // Sleep for 3 seconds so that any future reads will be later than timeBeforeDataCreation.
+      await sleep(3000);
+    });
+
     it('should run in a transaction', async () => {
       const key = datastore.key(['Company', 'Google']);
       const obj = {
@@ -1669,18 +1690,21 @@ describe('Datastore', () => {
       assert.strictEqual(incompleteKey.path.length, 2);
     });
 
-    it('should query within a transaction', async () => {
+    it('should query within a transaction at a previous read time', async () => {
       const transaction = datastore.transaction();
       await transaction.run();
       const query = transaction.createQuery('Company');
-      let entities;
+      let entitiesBefore;
+      let entitiesNow;
       try {
-        [entities] = await query.run();
+        [entitiesBefore] = await query.run({readTime: timeBeforeDataCreation});
+        [entitiesNow] = await query.run({});
       } catch (e) {
         await transaction.rollback();
         return;
       }
-      assert(entities!.length > 0);
+      assert.strictEqual(entitiesBefore!.length, 0);
+      assert(entitiesNow!.length > 0);
       await transaction.commit();
     });