feat: Upgrade to Parse JavaScript SDK 4 (parse-community#8332)

Author: dblythy

package.json

@@ -48,7 +48,7 @@
     "mime": "3.0.0",
     "mongodb": "4.10.0",
     "mustache": "4.2.0",
-    "parse": "3.4.2",
+    "parse": "4.0.0",
     "path-to-regexp": "0.1.7",
     "pg-monitor": "1.5.0",
     "pg-promise": "10.12.1",

spec/ParseLiveQuery.spec.js

@@ -7,6 +7,15 @@ const validatorFail = () => {
 };
 
 describe('ParseLiveQuery', function () {
+  beforeEach(() => {
+    Parse.CoreManager.getLiveQueryController().setDefaultLiveQueryClient(null);
+  });
+  afterEach(async () => {
+    const client = await Parse.CoreManager.getLiveQueryController().getDefaultLiveQueryClient();
+    client.close();
+    // Wait for live query client to disconnect
+    await new Promise(resolve => setTimeout(resolve, 1000));
+  });
   it('access user on onLiveQueryEvent disconnect', async done => {
     await reconfigureServer({
       liveQuery: {
@@ -16,7 +25,6 @@ describe('ParseLiveQuery', function () {
       verbose: false,
       silent: true,
     });
-    Parse.CoreManager.getLiveQueryController().setDefaultLiveQueryClient(null);
     const requestedUser = new Parse.User();
     requestedUser.setUsername('username');
     requestedUser.setPassword('password');
@@ -513,88 +521,77 @@ describe('ParseLiveQuery', function () {
         classNames: ['TestObject'],
       },
       startLiveQueryServer: true,
-      verbose: false,
-      silent: true,
     });
     const object = new TestObject();
     await object.save();
-
-    Parse.Cloud.beforeSubscribe('TestObject', req => {
-      expect(req.op).toBe('subscribe');
-      expect(req.requestId).toBe(1);
-      expect(req.query).toBeDefined();
-      expect(req.user).toBeUndefined();
-    });
-
-    Parse.Cloud.beforeConnect(req => {
-      expect(req.event).toBe('connect');
-      expect(req.clients).toBe(0);
-      expect(req.subscriptions).toBe(0);
-      expect(req.useMasterKey).toBe(false);
-      expect(req.installationId).toBeDefined();
-      expect(req.user).toBeUndefined();
-      expect(req.client).toBeDefined();
-    });
+    const hooks = {
+      beforeSubscribe(req) {
+        expect(req.op).toBe('subscribe');
+        expect(req.requestId).toBe(1);
+        expect(req.query).toBeDefined();
+        expect(req.user).toBeUndefined();
+      },
+      beforeConnect(req) {
+        expect(req.event).toBe('connect');
+        expect(req.clients).toBe(0);
+        expect(req.subscriptions).toBe(0);
+        expect(req.useMasterKey).toBe(false);
+        expect(req.installationId).toBeDefined();
+        expect(req.user).toBeUndefined();
+        expect(req.client).toBeDefined();
+      },
+    };
+    spyOn(hooks, 'beforeSubscribe').and.callThrough();
+    spyOn(hooks, 'beforeConnect').and.callThrough();
+    Parse.Cloud.beforeSubscribe('TestObject', hooks.beforeSubscribe);
+    Parse.Cloud.beforeConnect(hooks.beforeConnect);
     const query = new Parse.Query(TestObject);
     query.equalTo('objectId', object.id);
     const subscription = await query.subscribe();
     subscription.on('update', object => {
       expect(object.get('foo')).toBe('bar');
+      expect(hooks.beforeConnect).toHaveBeenCalled();
+      expect(hooks.beforeSubscribe).toHaveBeenCalled();
       done();
     });
     object.set({ foo: 'bar' });
     await object.save();
   });
 
-  it('can handle beforeConnect validation function', async done => {
+  it('can handle beforeConnect validation function', async () => {
     await reconfigureServer({
       liveQuery: {
         classNames: ['TestObject'],
       },
       startLiveQueryServer: true,
-      verbose: false,
-      silent: true,
     });
 
     const object = new TestObject();
     await object.save();
-
     Parse.Cloud.beforeConnect(() => {}, validatorFail);
-    let complete = false;
-    Parse.LiveQuery.on('error', error => {
-      Parse.LiveQuery.removeAllListeners('error');
-      if (complete) {
-        return;
-      }
-      complete = true;
-      expect(error).toBe('you are not authorized');
-      done();
-    });
     const query = new Parse.Query(TestObject);
     query.equalTo('objectId', object.id);
-    await query.subscribe();
+    await expectAsync(query.subscribe()).toBeRejectedWith(
+      new Parse.Error(Parse.Error.VALIDATION_ERROR, 'you are not authorized')
+    );
   });
 
-  it('can handle beforeSubscribe validation function', async done => {
+  it('can handle beforeSubscribe validation function', async () => {
     await reconfigureServer({
       liveQuery: {
         classNames: ['TestObject'],
       },
       startLiveQueryServer: true,
-      verbose: false,
-      silent: true,
     });
     const object = new TestObject();
     await object.save();
 
     Parse.Cloud.beforeSubscribe(TestObject, () => {}, validatorFail);
     const query = new Parse.Query(TestObject);
     query.equalTo('objectId', object.id);
-    const subscription = await query.subscribe();
-    subscription.on('error', error => {
-      expect(error).toBe('you are not authorized');
-      done();
-    });
+    await expectAsync(query.subscribe()).toBeRejectedWith(
+      new Parse.Error(Parse.Error.VALIDATION_ERROR, 'you are not authorized')
+    );
   });
 
   it('can handle afterEvent validation function', async done => {
@@ -620,29 +617,22 @@ describe('ParseLiveQuery', function () {
     await object.save();
   });
 
-  it('can handle beforeConnect error', async done => {
+  it('can handle beforeConnect error', async () => {
     await reconfigureServer({
       liveQuery: {
         classNames: ['TestObject'],
       },
       startLiveQueryServer: true,
-      verbose: false,
-      silent: true,
     });
     const object = new TestObject();
     await object.save();
 
     Parse.Cloud.beforeConnect(() => {
       throw new Error('You shall not pass!');
     });
-    Parse.LiveQuery.on('error', error => {
-      Parse.LiveQuery.removeAllListeners('error');
-      expect(error).toBe('You shall not pass!');
-      done();
-    });
     const query = new Parse.Query(TestObject);
     query.equalTo('objectId', object.id);
-    await query.subscribe();
+    await expectAsync(query.subscribe()).toBeRejectedWith(new Error('You shall not pass!'));
   });
 
   it('can log on beforeConnect throw', async () => {
@@ -651,8 +641,6 @@ describe('ParseLiveQuery', function () {
         classNames: ['TestObject'],
       },
       startLiveQueryServer: true,
-      verbose: false,
-      silent: true,
     });
 
     const logger = require('../lib/logger').logger;
@@ -664,40 +652,30 @@ describe('ParseLiveQuery', function () {
       foo.bar();
       /* eslint-enable no-undef */
     });
-    new Parse.Query(TestObject).subscribe();
-    await new Promise(resolve => Parse.LiveQuery.on('error', resolve));
-    Parse.LiveQuery.removeAllListeners('error');
+    await expectAsync(new Parse.Query(TestObject).subscribe()).toBeRejectedWith(
+      new Error('foo is not defined')
+    );
     expect(logger.error).toHaveBeenCalledWith(
       `Failed running beforeConnect for session ${token} with:\n Error: {"message":"foo is not defined","code":141}`
     );
   });
 
-  it('can handle beforeSubscribe error', async done => {
+  it('can handle beforeSubscribe error', async () => {
     await reconfigureServer({
       liveQuery: {
         classNames: ['TestObject'],
       },
       startLiveQueryServer: true,
-      verbose: false,
-      silent: true,
     });
     const object = new TestObject();
     await object.save();
 
     Parse.Cloud.beforeSubscribe(TestObject, () => {
       throw new Error('You shall not subscribe!');
     });
-    Parse.LiveQuery.on('error', error => {
-      expect(error).toBe('You shall not subscribe!');
-    });
     const query = new Parse.Query(TestObject);
     query.equalTo('objectId', object.id);
-    const subscription = await query.subscribe();
-    subscription.on('error', error => {
-      Parse.LiveQuery.removeAllListeners('error');
-      expect(error).toBe('You shall not subscribe!');
-      done();
-    });
+    await expectAsync(query.subscribe()).toBeRejectedWith(new Error('You shall not subscribe!'));
   });
 
   it('can log on beforeSubscribe error', async () => {
@@ -706,8 +684,6 @@ describe('ParseLiveQuery', function () {
         classNames: ['TestObject'],
       },
       startLiveQueryServer: true,
-      verbose: false,
-      silent: true,
     });
 
     const logger = require('../lib/logger').logger;
@@ -720,8 +696,7 @@ describe('ParseLiveQuery', function () {
     });
 
     const query = new Parse.Query(TestObject);
-    const subscription = await query.subscribe();
-    await new Promise(resolve => subscription.on('error', resolve));
+    await expectAsync(query.subscribe()).toBeRejectedWith(new Error('foo is not defined'));
 
     expect(logger.error).toHaveBeenCalledWith(
       `Failed running beforeSubscribe on TestObject for session undefined with:\n Error: {"message":"foo is not defined","code":141}`
@@ -734,29 +709,35 @@ describe('ParseLiveQuery', function () {
         classNames: ['TestObject'],
       },
       startLiveQueryServer: true,
-      verbose: false,
-      silent: true,
-    });
-    Parse.Cloud.beforeSubscribe(TestObject, request => {
-      const query = request.query;
-      query.equalTo('yolo', 'abc');
     });
-
+    const hook = {
+      beforeSubscribe(request) {
+        request.query.equalTo('yolo', 'abc');
+      },
+    };
+    spyOn(hook, 'beforeSubscribe').and.callThrough();
+    Parse.Cloud.beforeSubscribe('TestObject', hook.beforeSubscribe);
     const object = new TestObject();
     await object.save();
 
-    const query = new Parse.Query(TestObject);
+    const query = new Parse.Query('TestObject');
     query.equalTo('objectId', object.id);
     const subscription = await query.subscribe();
-
     subscription.on('update', () => {
-      fail();
+      fail('beforeSubscribe should restrict subscription');
     });
-    object.set({ foo: 'bar' });
+    subscription.on('enter', object => {
+      if (object.get('yolo') === 'abc') {
+        done();
+      } else {
+        fail('beforeSubscribe should restrict queries');
+      }
+    });
+    object.set({ yolo: 'bar' });
     await object.save();
-    setTimeout(async () => {
-      done();
-    }, 1000);
+    object.set({ yolo: 'abc' });
+    await object.save();
+    expect(hook.beforeSubscribe).toHaveBeenCalled();
   });
 
   it('can return a new beforeSubscribe query', async done => {
@@ -954,26 +935,15 @@ describe('ParseLiveQuery', function () {
     await Parse.User.logIn('username', 'password');
   });
 
-  it('prevent liveQuery on Session class when not logged in', async done => {
+  it('prevent liveQuery on Session class when not logged in', async () => {
     await reconfigureServer({
       liveQuery: {
         classNames: [Parse.Session],
       },
       startLiveQueryServer: true,
-      verbose: false,
-      silent: true,
-    });
-
-    Parse.LiveQuery.on('error', error => {
-      expect(error).toBe('Invalid session token');
     });
     const query = new Parse.Query(Parse.Session);
-    const subscription = await query.subscribe();
-    subscription.on('error', error => {
-      Parse.LiveQuery.removeAllListeners('error');
-      expect(error).toBe('Invalid session token');
-      done();
-    });
+    await expectAsync(query.subscribe()).toBeRejectedWith(new Error('Invalid session token'));
   });
 
   it('handle invalid websocket payload length', async done => {
@@ -1242,13 +1212,4 @@ describe('ParseLiveQuery', function () {
     object.set({ location: secondPoint });
     await object.save();
   });
-
-  afterEach(async function (done) {
-    const client = await Parse.CoreManager.getLiveQueryController().getDefaultLiveQueryClient();
-    client.close();
-    // Wait for live query client to disconnect
-    setTimeout(() => {
-      done();
-    }, 1000);
-  });
 });