Independent sessions test

Author: davimacedo

spec/batch.spec.js

@@ -69,6 +69,12 @@ describe('batch', () => {
   });
 
   it('should handle a batch request without transaction', done => {
+    let calls = 0;
+    Parse.Cloud.beforeSave('MyObject', ({ config }) => {
+      calls++;
+      expect(config.database._transactionalSession).toEqual(null);
+    });
+
     request({
       method: 'POST',
       headers: headers,
@@ -95,6 +101,7 @@ describe('batch', () => {
       expect(response.data[1].success.createdAt).toBeDefined();
       const query = new Parse.Query('MyObject');
       query.find().then(results => {
+        expect(calls).toBe(2);
         expect(results.map(result => result.get('key')).sort()).toEqual([
           'value1',
           'value2',
@@ -105,6 +112,12 @@ describe('batch', () => {
   });
 
   it('should handle a batch request with transaction = false', done => {
+    let calls = 0;
+    Parse.Cloud.beforeSave('MyObject', ({ config }) => {
+      calls++;
+      expect(config.database._transactionalSession).toEqual(null);
+    });
+
     request({
       method: 'POST',
       headers: headers,
@@ -132,6 +145,7 @@ describe('batch', () => {
       expect(response.data[1].success.createdAt).toBeDefined();
       const query = new Parse.Query('MyObject');
       query.find().then(results => {
+        expect(calls).toBe(2);
         expect(results.map(result => result.get('key')).sort()).toEqual([
           'value1',
           'value2',
@@ -142,6 +156,20 @@ describe('batch', () => {
   });
 
   it('should handle a batch request with transaction = true', done => {
+    let calls = 0;
+    let transactionalSession = null;
+    Parse.Cloud.beforeSave('MyObject', ({ config }) => {
+      calls++;
+      expect(config.database._transactionalSession).not.toEqual(null);
+      if (transactionalSession) {
+        expect(config.database._transactionalSession).toBe(
+          transactionalSession
+        );
+      } else {
+        transactionalSession = config.database._transactionalSession;
+      }
+    });
+
     request({
       method: 'POST',
       headers: headers,
@@ -169,6 +197,7 @@ describe('batch', () => {
       expect(response.data[1].success.createdAt).toBeDefined();
       const query = new Parse.Query('MyObject');
       query.find().then(results => {
+        expect(calls).toBe(2);
         expect(results.map(result => result.get('key')).sort()).toEqual([
           'value1',
           'value2',
@@ -177,4 +206,133 @@ describe('batch', () => {
       });
     });
   });
+
+  it('should generate separate session for each call', done => {
+    let myObjectCalls = 0;
+    let myObjectTransactionalSession = null;
+
+    Parse.Cloud.beforeSave('MyObject', ({ config }) => {
+      myObjectCalls++;
+      expect(config.database._transactionalSession).not.toEqual(null);
+      if (myObjectTransactionalSession) {
+        expect(config.database._transactionalSession).toBe(
+          myObjectTransactionalSession
+        );
+      } else {
+        myObjectTransactionalSession = config.database._transactionalSession;
+      }
+
+      if (myObjectCalls === 1) {
+        return request({
+          method: 'POST',
+          headers: headers,
+          url: 'http://localhost:8378/1/batch',
+          body: JSON.stringify({
+            requests: [
+              {
+                method: 'POST',
+                path: '/1/classes/MyObject2',
+                body: { key: 'value1' },
+              },
+              {
+                method: 'POST',
+                path: '/1/classes/MyObject2',
+                body: { key: 'value2' },
+              },
+            ],
+            transaction: true,
+          }),
+        }).then(() => Promise.resolve());
+      }
+    });
+
+    let myObject2Calls = 0;
+    let myObject2TransactionalSession = null;
+    Parse.Cloud.beforeSave('MyObject2', ({ config }) => {
+      myObject2Calls++;
+      expect(config.database._transactionalSession).not.toEqual(null);
+      if (myObject2TransactionalSession) {
+        expect(config.database._transactionalSession).toBe(
+          myObject2TransactionalSession
+        );
+      } else {
+        myObject2TransactionalSession = config.database._transactionalSession;
+      }
+
+      if (myObject2Calls === 1) {
+        return request({
+          method: 'POST',
+          headers: headers,
+          url: 'http://localhost:8378/1/batch',
+          body: JSON.stringify({
+            requests: [
+              {
+                method: 'POST',
+                path: '/1/classes/MyObject3',
+                body: { key: 'value1' },
+              },
+              {
+                method: 'POST',
+                path: '/1/classes/MyObject3',
+                body: { key: 'value2' },
+              },
+            ],
+          }),
+        }).then(() => Promise.resolve());
+      }
+    });
+
+    let myObject3Calls = 0;
+    Parse.Cloud.beforeSave('MyObject3', ({ config }) => {
+      myObject3Calls++;
+      expect(config.database._transactionalSession).toEqual(null);
+    });
+
+    request({
+      method: 'POST',
+      headers: headers,
+      url: 'http://localhost:8378/1/batch',
+      body: JSON.stringify({
+        requests: [
+          {
+            method: 'POST',
+            path: '/1/classes/MyObject',
+            body: { key: 'value1' },
+          },
+          {
+            method: 'POST',
+            path: '/1/classes/MyObject',
+            body: { key: 'value2' },
+          },
+        ],
+        transaction: true,
+      }),
+    }).then(() => {
+      const query = new Parse.Query('MyObject');
+      query.find().then(results => {
+        expect(myObjectCalls).toBe(2);
+        expect(results.map(result => result.get('key')).sort()).toEqual([
+          'value1',
+          'value2',
+        ]);
+        const query = new Parse.Query('MyObject2');
+        query.find().then(results => {
+          expect(myObject2Calls).toBe(2);
+          expect(results.map(result => result.get('key')).sort()).toEqual([
+            'value1',
+            'value2',
+          ]);
+          const query = new Parse.Query('MyObject3');
+          query.find().then(results => {
+            expect(myObject3Calls).toBe(2);
+            expect(results.map(result => result.get('key')).sort()).toEqual([
+              'value1',
+              'value2',
+            ]);
+            done();
+          });
+        });
+      });
+    });
+  });
 });

src/triggers.js

@@ -179,6 +179,7 @@ export function getRequestObject(
     log: config.loggerController,
     headers: config.headers,
     ip: config.ip,
+    config: config,
   };
 
   if (originalParseObject) {