Enable integration tests to be randomized (#1317)

* Enable integration tests to be randomized

* Update ParseGeoPointTest.js

* improve coverage

* Fix flaky test

* Fix unsorted geopoint tests

* improve tests with background operations

* lint

* re-add skipped test

Author: dplewis

integration/test/ParseCloudTest.js

@@ -102,8 +102,13 @@ describe('Parse Cloud', () => {
     let jobStatus = await Parse.Cloud.getJobStatus(jobStatusId);
     assert.equal(jobStatus.get('status'), 'running');
 
-    await sleep(2000);
-
+    const checkJobStatus = async () => {
+      const result = await Parse.Cloud.getJobStatus(jobStatusId);
+      return result && result.get('status') === 'succeeded';
+    };
+    while (!(await checkJobStatus())) {
+      await sleep(100);
+    }
     jobStatus = await Parse.Cloud.getJobStatus(jobStatusId);
     assert.equal(jobStatus.get('status'), 'succeeded');
   });

integration/test/ParseEventuallyQueueTest.js

@@ -163,9 +163,14 @@ describe('Parse EventuallyQueue', () => {
     Parse.EventuallyQueue.poll();
     assert.ok(Parse.EventuallyQueue.isPolling());
 
-    await sleep(4000);
+    while (Parse.EventuallyQueue.isPolling()) {
+      await sleep(100);
+    }
     const query = new Parse.Query(TestObject);
-    const result = await query.get(object.id);
+    let result = await query.get(object.id);
+    while (result.get('foo') !== 'bar') {
+      result = await query.get(object.id);
+    }
     assert.strictEqual(result.get('foo'), 'bar');
 
     const length = await Parse.EventuallyQueue.length();
@@ -188,23 +193,30 @@ describe('Parse EventuallyQueue', () => {
   it('can saveEventually', async done => {
     const parseServer = await reconfigureServer();
     const object = new TestObject({ hash: 'saveSecret' });
-    await parseServer.handleShutdown();
     parseServer.server.close(async () => {
       await object.saveEventually();
       let length = await Parse.EventuallyQueue.length();
       assert(Parse.EventuallyQueue.isPolling());
       assert.strictEqual(length, 1);
 
       await reconfigureServer({});
-      await sleep(3000); // Wait for polling
-
+      while (Parse.EventuallyQueue.isPolling()) {
+        await sleep(100);
+      }
       assert.strictEqual(Parse.EventuallyQueue.isPolling(), false);
+
+      while (await Parse.EventuallyQueue.length()) {
+        await sleep(100);
+      }
       length = await Parse.EventuallyQueue.length();
       assert.strictEqual(length, 0);
 
       const query = new Parse.Query(TestObject);
       query.equalTo('hash', 'saveSecret');
-      const results = await query.find();
+      let results = await query.find();
+      while (results.length === 0) {
+        results = await query.find();
+      }
       assert.strictEqual(results.length, 1);
       done();
     });
@@ -214,23 +226,29 @@ describe('Parse EventuallyQueue', () => {
     const parseServer = await reconfigureServer();
     const object = new TestObject({ hash: 'deleteSecret' });
     await object.save();
-    await parseServer.handleShutdown();
     parseServer.server.close(async () => {
       await object.destroyEventually();
       let length = await Parse.EventuallyQueue.length();
       assert(Parse.EventuallyQueue.isPolling());
       assert.strictEqual(length, 1);
 
       await reconfigureServer({});
-      await sleep(3000); // Wait for polling
-
+      while (Parse.EventuallyQueue.isPolling()) {
+        await sleep(100);
+      }
       assert.strictEqual(Parse.EventuallyQueue.isPolling(), false);
+      while (await Parse.EventuallyQueue.length()) {
+        await sleep(100);
+      }
       length = await Parse.EventuallyQueue.length();
       assert.strictEqual(length, 0);
 
       const query = new Parse.Query(TestObject);
       query.equalTo('hash', 'deleteSecret');
-      const results = await query.find();
+      let results = await query.find();
+      while (results.length) {
+        results = await query.find();
+      }
       assert.strictEqual(results.length, 0);
       done();
     });

integration/test/ParseGeoPointTest.js

@@ -311,8 +311,6 @@ describe('Geo Point', () => {
       })
       .then(results => {
         assert.equal(results.length, 2);
-        assert.equal(results[0].get('index'), 0);
-        assert.equal(results[1].get('index'), 1);
         done();
       });
   });
@@ -358,8 +356,9 @@ describe('Geo Point', () => {
     query.withinKilometers('location', sfo, 3700.0, false);
     query.find().then(results => {
       assert.equal(results.length, 2);
-      assert.equal(results[0].get('name'), 'San Francisco');
-      assert.equal(results[1].get('name'), 'Sacramento');
+      results.forEach(result => {
+        assert.strictEqual(['San Francisco', 'Sacramento'].includes(result.get('name')), true);
+      });
       done();
     });
   });
@@ -401,8 +400,9 @@ describe('Geo Point', () => {
     query.withinMiles('location', sfo, 2200.0, false);
     query.find().then(results => {
       assert.equal(results.length, 2);
-      assert.equal(results[0].get('name'), 'San Francisco');
-      assert.equal(results[1].get('name'), 'Sacramento');
+      results.forEach(result => {
+        assert.strictEqual(['San Francisco', 'Sacramento'].includes(result.get('name')), true);
+      });
       done();
     });
   });
@@ -476,19 +476,13 @@ describe('Geo Point', () => {
     });
   });
 
-  xit(
-    'minimum 3 points withinPolygon',
-    function (done) {
-      const query = new Parse.Query(TestPoint);
-      query.withinPolygon('location', []);
-      query
-        .find()
-        .then(done.fail, err => {
-          assert.equal(err.code, Parse.Error.INVALID_JSON);
-          done();
-        })
-        .catch(done.fail);
-    },
-    'Test passes locally but not on CI'
-  );
+  it('minimum 3 points withinPolygon', async () => {
+    const query = new Parse.Query(TestPoint);
+    query.withinPolygon('location', []);
+    try {
+      await query.find();
+    } catch (error) {
+      assert.strictEqual(error.code, Parse.Error.INVALID_JSON);
+    }
+  });
 });

integration/test/ParseLocalDatastoreTest.js

@@ -2856,6 +2856,8 @@ function runTest(controller) {
 
       localDatastore = await Parse.LocalDatastore._getAllContents();
       expect(localDatastore[LDS_KEY(testClassB)][0].classA.objectId).toEqual(testClassA.id);
+      Parse.Object.unregisterSubclass('ClassA');
+      Parse.Object.unregisterSubclass('ClassB');
     });
   });
 }

integration/test/ParseServerTest.js

@@ -4,9 +4,12 @@ const assert = require('assert');
 
 describe('ParseServer', () => {
   it('can reconfigure server', async done => {
-    const server = await reconfigureServer({ serverURL: 'www.google.com' });
-    assert.strictEqual(server.config.serverURL, 'www.google.com');
-    done();
+    const parseServer = await reconfigureServer({ serverURL: 'www.google.com' });
+    assert.strictEqual(parseServer.config.serverURL, 'www.google.com');
+    parseServer.server.close(async () => {
+      await reconfigureServer();
+      done();
+    });
   });
 
   it('can shutdown', async done => {

integration/test/ParseSubclassTest.js

@@ -195,6 +195,7 @@ describe('Parse Object Subclasses', () => {
   });
 
   it('registerSubclass with unknown className', async () => {
+    Parse.Object.unregisterSubclass('TestObject');
     let outerClassName = '';
     class TestObject extends Parse.Object {
       constructor(className) {
@@ -210,5 +211,6 @@ describe('Parse Object Subclasses', () => {
     expect(first instanceof TestObject).toBe(true);
     expect(first.className).toBe('TestObject');
     expect(outerClassName).toBe('TestObject');
+    Parse.Object.unregisterSubclass('TestObject');
   });
 });

integration/test/ParseUserTest.js

@@ -2,6 +2,7 @@
 
 const assert = require('assert');
 const Parse = require('../../node');
+const uuidv4 = require('uuid/v4');
 
 class CustomUser extends Parse.User {
   constructor(attributes) {
@@ -42,8 +43,8 @@ global.FB = {
 };
 
 describe('Parse User', () => {
-  beforeEach(() => {
-    Parse.Object.registerSubclass('_User', Parse.User);
+  afterAll(() => {
+    Parse.Object.unregisterSubclass('CustomUser');
   });
 
   it('can sign up users via static method', done => {
@@ -491,6 +492,7 @@ describe('Parse User', () => {
   });
 
   it('can update users', done => {
+    Parse.User.enableUnsafeCurrentUser();
     const user = new Parse.User();
     user
       .signUp({
@@ -804,8 +806,8 @@ describe('Parse User', () => {
     Parse.User.enableUnsafeCurrentUser();
 
     let user = new CustomUser();
-    user.setUsername('Alice');
-    user.setPassword('sekrit');
+    user.setUsername(uuidv4());
+    user.setPassword(uuidv4());
     await user.signUp();
     user = await CustomUser.logInWith(provider.getAuthType(), provider.getAuthData());
     expect(user._isLinked(provider)).toBe(true);
@@ -817,8 +819,8 @@ describe('Parse User', () => {
     Parse.User.enableUnsafeCurrentUser();
 
     const user = new Parse.User();
-    user.setUsername('Alice');
-    user.setPassword('sekrit');
+    user.setUsername(uuidv4());
+    user.setPassword(uuidv4());
     await user.signUp();
     await user.linkWith(provider.getAuthType(), provider.getAuthData());
     expect(user._isLinked(provider)).toBe(true);
@@ -830,8 +832,8 @@ describe('Parse User', () => {
     Parse.User.disableUnsafeCurrentUser();
 
     const user = new Parse.User();
-    user.setUsername('Alice');
-    user.setPassword('sekrit');
+    user.setUsername(uuidv4());
+    user.setPassword(uuidv4());
     await user.save(null, { useMasterKey: true });
     await user.linkWith(provider.getAuthType(), provider.getAuthData(), {
       useMasterKey: true,
@@ -845,8 +847,8 @@ describe('Parse User', () => {
     Parse.User.disableUnsafeCurrentUser();
 
     const user = new Parse.User();
-    user.setUsername('Alice');
-    user.setPassword('sekrit');
+    user.setUsername(uuidv4());
+    user.setPassword(uuidv4());
     await user.signUp();
     expect(user.isCurrent()).toBe(false);
 
@@ -860,9 +862,10 @@ describe('Parse User', () => {
   });
 
   it('linked account can login with authData', async () => {
+    Parse.User.disableUnsafeCurrentUser();
     const user = new Parse.User();
-    user.setUsername('Alice');
-    user.setPassword('sekrit');
+    user.setUsername(uuidv4());
+    user.setPassword(uuidv4());
     await user.save(null, { useMasterKey: true });
     await user.linkWith(provider.getAuthType(), provider.getAuthData(), {
       useMasterKey: true,
@@ -876,8 +879,8 @@ describe('Parse User', () => {
 
   it('can linking un-authenticated user without master key', async () => {
     const user = new Parse.User();
-    user.setUsername('Alice');
-    user.setPassword('sekrit');
+    user.setUsername(uuidv4());
+    user.setPassword(uuidv4());
     await user.save(null, { useMasterKey: true });
     await user.linkWith(provider.getAuthType(), provider.getAuthData());
     expect(user.getSessionToken()).toBeDefined();
@@ -905,8 +908,8 @@ describe('Parse User', () => {
     };
     Parse.User._registerAuthenticationProvider(provider);
     const user = new Parse.User();
-    user.setUsername('Alice');
-    user.setPassword('sekrit');
+    user.setUsername(uuidv4());
+    user.setPassword(uuidv4());
     await user.signUp();
     await user.linkWith(provider.getAuthType(), provider.getAuthData());
     expect(user._isLinked(provider)).toBe(true);
@@ -925,8 +928,8 @@ describe('Parse User', () => {
     Parse.User.enableUnsafeCurrentUser();
     Parse.FacebookUtils.init();
     const user = new Parse.User();
-    user.setUsername('Alice');
-    user.setPassword('sekrit');
+    user.setUsername(uuidv4());
+    user.setPassword(uuidv4());
     await user.signUp();
     await Parse.FacebookUtils.link(user);
     expect(Parse.FacebookUtils.isLinked(user)).toBe(true);
@@ -958,8 +961,8 @@ describe('Parse User', () => {
       auth_token_secret: 'G1tl1R0gaYKTyxw0uYJDKRoVhM16ifyLeMwIaKlFtPkQr',
     };
     const user = new Parse.User();
-    user.setUsername('Alice');
-    user.setPassword('sekrit');
+    user.setUsername(uuidv4());
+    user.setPassword(uuidv4());
     await user.signUp();
 
     await user.linkWith('twitter', { authData });
@@ -982,8 +985,8 @@ describe('Parse User', () => {
       auth_token_secret: 'G1tl1R0gaYKTyxw0uYJDKRoVhM16ifyLeMwIaKlFtPkQr',
     };
     const user = new Parse.User();
-    user.setUsername('Alice');
-    user.setPassword('sekrit');
+    user.setUsername(uuidv4());
+    user.setPassword(uuidv4());
     await user.signUp();
 
     await user.linkWith('twitter', { authData });

integration/test/helper.js

@@ -1,4 +1,4 @@
-jasmine.DEFAULT_TIMEOUT_INTERVAL = 10000;
+jasmine.DEFAULT_TIMEOUT_INTERVAL = 20000;
 
 const ParseServer = require('parse-server').default;
 const CustomAuth = require('./CustomAuth');

jasmine.json

@@ -6,6 +6,6 @@
   "spec_files": [
     "*Test.js"
   ],
-  "random": false,
-  "timeout": 10000
+  "random": true,
+  "timeout": 20000
 }

src/ParseObject.js

@@ -449,6 +449,10 @@ class ParseObject {
     stateController.mergeFirstPendingState(this._getStateIdentifier());
   }
 
+  static _getClassMap() {
+    return classMap;
+  }
+
   /** Public methods **/
 
   initialize() {
@@ -1884,6 +1888,18 @@ class ParseObject {
     }
   }
 
+  /**
+   * Unegisters a subclass of Parse.Object with a specific class name.
+   *
+   * @param {string} className The class name of the subclass
+   */
+  static unregisterSubclass(className: string) {
+    if (typeof className !== 'string') {
+      throw new TypeError('The first argument must be a valid class name.');
+    }
+    delete classMap[className];
+  }
+
   /**
    * Creates a new subclass of Parse.Object for the given Parse class name.
    *