[WIP] Enable test suite to be randomized (#7265)

* initial run

* Update ParseGraphQLServer.spec.js

* temporarily enable reporter

* Bump retry limit

* fix undefined database

* try to catch error

* Handle LiveQueryServers

* Update Config.js

* fast-fail false

* Remove usage of AppCache

* oops

* Update contributing guide

* enable debugger, try network retry attempt 1

* Fix ldap unbinding

* move non specs to support

* add missing mock adapter

* fix Parse.Push

* RestController should match batch.spec.js

* Remove request attempt limit

* handle index.spec.js

* Update CHANGELOG.md

* Handle error: tuple concurrently updated

* test transactions

* Clear RedisCache after every test

* LoggerController.spec.js

* Update schemas.spec.js

* finally fix transactions

* fix geopoint deadlock

* transaction with clean database

* batch.spec.js

.github/workflows/ci.yml

@@ -13,7 +13,7 @@ env:
 jobs:
   check-ci:
     name: CI Self-Check
-    timeout-minutes: 30
+    timeout-minutes: 15
     runs-on: ubuntu-18.04
     steps:
       - uses: actions/checkout@v2
@@ -34,7 +34,7 @@ jobs:
         run: npm run ci:check
   check-lint:
      name: Lint
-     timeout-minutes: 30
+     timeout-minutes: 15
      runs-on: ubuntu-18.04
      steps:
        - uses: actions/checkout@v2
@@ -97,8 +97,9 @@ jobs:
             MONGODB_TOPOLOGY: standalone
             MONGODB_STORAGE_ENGINE: wiredTiger
             NODE_VERSION: 15.11.0
+      fail-fast: false
     name: ${{ matrix.name }}
-    timeout-minutes: 30
+    timeout-minutes: 15
     runs-on: ubuntu-18.04
     services:
       redis:
@@ -145,8 +146,9 @@ jobs:
             POSTGRES_IMAGE: postgis/postgis:12-3.0
           - name: Postgres 13, Postgis 3.1
             POSTGRES_IMAGE: postgis/postgis:13-3.1
+      fail-fast: false
     name: ${{ matrix.name }}
-    timeout-minutes: 30
+    timeout-minutes: 15
     runs-on: ubuntu-18.04
     services:
       redis:

CHANGELOG.md

@@ -114,6 +114,8 @@ ___
 - Allow Cloud Validator `options` to be async (dblythy) [#7155](https://github.com/parse-community/parse-server/pull/7155)
 - Optimize queries on classes with pointer permissions (Pedro Diaz) [#7061](https://github.com/parse-community/parse-server/pull/7061)
 - Test Parse Server continuously against all relevant Postgres versions (minor versions), added Postgres compatibility table to Parse Server docs (Corey Baker) [#7176](https://github.com/parse-community/parse-server/pull/7176)
+- Randomize test suite (Diamond Lewis) [#7265](https://github.com/parse-community/parse-server/pull/7265)
+- LDAP: Properly unbind client on group search error (Diamond Lewis) [#7265](https://github.com/parse-community/parse-server/pull/7265)
 ___
 ## 4.5.0
 [Full Changelog](https://github.com/parse-community/parse-server/compare/4.4.0...4.5.0)

CONTRIBUTING.md

@@ -84,6 +84,14 @@ Once you have babel running in watch mode, you can start making changes to parse
 * All the tests should point to sources in the `lib/` folder.
 * The `lib/` folder is produced by `babel` using either the `npm run build`, `npm run watch`, or the `npm run prepare` step.
 * The `npm run prepare` step is automatically invoked when your package depends on forked parse-server installed via git for example using `npm install --save git+https://github.com/[username]/parse-server#[branch/commit]`.
+* The tests are run against a single server instance. You can change the server configurations using `await reconfigureServer({ ... some configuration })` found in `spec/helper.js`.
+* The tests are ran at random.
+* Caches and Configurations are reset after every test.
+* Users are logged out after every test.
+* Cloud Code hooks are removed after every test.
+* Database is deleted after every test (indexes are not removed for speed)
+* Tests are located in the `spec` folder
+* For better test reporting enable `PARSE_SERVER_LOG_LEVEL=debug`
 
 ### Troubleshooting
 
@@ -108,6 +116,7 @@ Once you have babel running in watch mode, you can start making changes to parse
 * Run the tests for the whole project to make sure the code passes all tests. This can be done by running the test command for a single file but removing the test file argument. The results can be seen at *<PROJECT_ROOT>/coverage/lcov-report/index.html*.
 * Lint your code by running `npm run lint` to make sure the code is not going to be rejected by the CI.
 * **Do not** publish the *lib* folder.
+* Mocks belong in the `spec/support` folder.
 * Please consider if any changes to the [docs](http://docs.parseplatform.org) are needed or add additional sections in the case of an enhancement or feature.
 
 ### Test against Postgres

spec/AdapterLoader.spec.js

@@ -6,7 +6,7 @@ const Config = require('../lib/Config');
 
 describe('AdapterLoader', () => {
   it('should instantiate an adapter from string in object', done => {
-    const adapterPath = require('path').resolve('./spec/MockAdapter');
+    const adapterPath = require('path').resolve('./spec/support/MockAdapter');
 
     const adapter = loadAdapter({
       adapter: adapterPath,
@@ -23,7 +23,7 @@ describe('AdapterLoader', () => {
   });
 
   it('should instantiate an adapter from string', done => {
-    const adapterPath = require('path').resolve('./spec/MockAdapter');
+    const adapterPath = require('path').resolve('./spec/support/MockAdapter');
     const adapter = loadAdapter(adapterPath);
 
     expect(adapter instanceof Object).toBe(true);
@@ -119,7 +119,7 @@ describe('AdapterLoader', () => {
   });
 
   it('should load custom push adapter from string (#3544)', done => {
-    const adapterPath = require('path').resolve('./spec/MockPushAdapter');
+    const adapterPath = require('path').resolve('./spec/support/MockPushAdapter');
     const options = {
       ios: {
         bundleId: 'bundle.id',

spec/CLI.spec.js

@@ -227,6 +227,8 @@ describe('execution', () => {
       'test',
       '--databaseURI',
       'mongodb://localhost/test',
+      '--port',
+      '1339',
     ]);
     childProcess.stdout.on('data', data => {
       data = data.toString();
@@ -247,6 +249,8 @@ describe('execution', () => {
       'test',
       '--databaseURI',
       'mongodb://localhost/test',
+      '--port',
+      '1340',
       '--mountGraphQL',
     ]);
     let output = '';
@@ -271,6 +275,8 @@ describe('execution', () => {
       'test',
       '--databaseURI',
       'mongodb://localhost/test',
+      '--port',
+      '1341',
       '--mountGraphQL',
       '--mountPlayground',
     ]);

spec/FilesController.spec.js

@@ -80,6 +80,9 @@ describe('FilesController', () => {
     expect(typeof error).toBe('object');
     expect(error.message.indexOf('biscuit')).toBe(13);
     expect(error.code).toBe(Parse.Error.INVALID_FILE_NAME);
+    mockAdapter.validateFilename = () => {
+      return null;
+    };
     done();
   });
 

spec/GridFSBucketStorageAdapter.spec.js

@@ -4,7 +4,6 @@ const GridFSBucketAdapter = require('../lib/Adapters/Files/GridFSBucketAdapter')
 const { randomString } = require('../lib/cryptoUtils');
 const databaseURI = 'mongodb://localhost:27017/parse';
 const request = require('../lib/request');
-const Config = require('../lib/Config');
 
 async function expectMissingFile(gfsAdapter, name) {
   try {
@@ -395,8 +394,9 @@ describe_only_db('mongo')('GridFSBucket and GridStore interop', () => {
   });
 
   it('should handle getMetadata error', async () => {
-    const config = Config.get('test');
+    const gfsAdapter = new GridFSBucketAdapter(databaseURI);
-    config.filesController.getMetadata = () => Promise.reject();
+    await reconfigureServer({ filesAdapter: gfsAdapter });
+    gfsAdapter.getMetadata = () => Promise.reject();
 
     const headers = {
       'X-Parse-Application-Id': 'test',

spec/LdapAuth.spec.js

@@ -1,5 +1,5 @@
 const ldap = require('../lib/Adapters/Auth/ldap');
-const mockLdapServer = require('./MockLdapServer');
+const mockLdapServer = require('./support/MockLdapServer');
 const fs = require('fs');
 const port = 12345;
 const sslport = 12346;
@@ -19,39 +19,31 @@ describe('Ldap Auth', () => {
     ldap.validateAppId().then(done).catch(done.fail);
   });
 
-  it('Should succeed with right credentials', done => {
+  it('Should succeed with right credentials', async done => {
-    mockLdapServer(port, 'uid=testuser, o=example').then(server => {
+    const server = await mockLdapServer(port, 'uid=testuser, o=example');
     const options = {
       suffix: 'o=example',
       url: `ldap://localhost:${port}`,
       dn: 'uid={{id}}, o=example',
     };
-      ldap
+    await ldap.validateAuthData({ id: 'testuser', password: 'secret' }, options);
-        .validateAuthData({ id: 'testuser', password: 'secret' }, options)
+    server.close(done);
-        .then(done)
-        .catch(done.fail)
-        .finally(() => server.close());
-    });
   });
 
-  it('Should succeed with right credentials when LDAPS is used and certifcate is not checked', done => {
+  it('Should succeed with right credentials when LDAPS is used and certifcate is not checked', async done => {
-    mockLdapServer(sslport, 'uid=testuser, o=example', false, true).then(server => {
+    const server = await mockLdapServer(sslport, 'uid=testuser, o=example', false, true);
     const options = {
       suffix: 'o=example',
       url: `ldaps://localhost:${sslport}`,
       dn: 'uid={{id}}, o=example',
       tlsOptions: { rejectUnauthorized: false },
     };
-      ldap
+    await ldap.validateAuthData({ id: 'testuser', password: 'secret' }, options);
-        .validateAuthData({ id: 'testuser', password: 'secret' }, options)
+    server.close(done);
-        .then(done)
-        .catch(done.fail)
-        .finally(() => server.close());
-    });
   });
 
-  it('Should succeed when LDAPS is used and the presented certificate is the expected certificate', done => {
+  it('Should succeed when LDAPS is used and the presented certificate is the expected certificate', async done => {
-    mockLdapServer(sslport, 'uid=testuser, o=example', false, true).then(server => {
+    const server = await mockLdapServer(sslport, 'uid=testuser, o=example', false, true);
     const options = {
       suffix: 'o=example',
       url: `ldaps://localhost:${sslport}`,
@@ -61,16 +53,12 @@ describe('Ldap Auth', () => {
         rejectUnauthorized: true,
       },
     };
-      ldap
+    await ldap.validateAuthData({ id: 'testuser', password: 'secret' }, options);
-        .validateAuthData({ id: 'testuser', password: 'secret' }, options)
+    server.close(done);
-        .then(done)
-        .catch(done.fail)
-        .finally(() => server.close());
-    });
   });
 
-  it('Should fail when LDAPS is used and the presented certificate is not the expected certificate', done => {
+  it('Should fail when LDAPS is used and the presented certificate is not the expected certificate', async done => {
-    mockLdapServer(sslport, 'uid=testuser, o=example', false, true).then(server => {
+    const server = await mockLdapServer(sslport, 'uid=testuser, o=example', false, true);
     const options = {
       suffix: 'o=example',
       url: `ldaps://localhost:${sslport}`,
@@ -80,19 +68,17 @@ describe('Ldap Auth', () => {
         rejectUnauthorized: true,
       },
     };
-      ldap
+    try {
-        .validateAuthData({ id: 'testuser', password: 'secret' }, options)
+      await ldap.validateAuthData({ id: 'testuser', password: 'secret' }, options);
-        .then(done.fail)
+      fail();
-        .catch(err => {
+    } catch (err) {
-          jequal(err.message, 'LDAPS: Certificate mismatch');
+      expect(err.message).toBe('LDAPS: Certificate mismatch');
-          done();
+    }
-        })
+    server.close(done);
-        .finally(() => server.close());
-    });
   });
 
-  it('Should fail when LDAPS is used certifcate matches but credentials are wrong', done => {
+  it('Should fail when LDAPS is used certifcate matches but credentials are wrong', async done => {
-    mockLdapServer(sslport, 'uid=testuser, o=example', false, true).then(server => {
+    const server = await mockLdapServer(sslport, 'uid=testuser, o=example', false, true);
     const options = {
       suffix: 'o=example',
       url: `ldaps://localhost:${sslport}`,
@@ -102,37 +88,33 @@ describe('Ldap Auth', () => {
         rejectUnauthorized: true,
       },
     };
-      ldap
+    try {
-        .validateAuthData({ id: 'testuser', password: 'wrong!' }, options)
+      await ldap.validateAuthData({ id: 'testuser', password: 'wrong!' }, options);
-        .then(done.fail)
+      fail();
-        .catch(err => {
+    } catch (err) {
-          jequal(err.message, 'LDAP: Wrong username or password');
+      expect(err.message).toBe('LDAP: Wrong username or password');
-          done();
+    }
-        })
+    server.close(done);
-        .finally(() => server.close());
-    });
   });
 
-  it('Should fail with wrong credentials', done => {
+  it('Should fail with wrong credentials', async done => {
-    mockLdapServer(port, 'uid=testuser, o=example').then(server => {
+    const server = await mockLdapServer(port, 'uid=testuser, o=example');
     const options = {
       suffix: 'o=example',
       url: `ldap://localhost:${port}`,
       dn: 'uid={{id}}, o=example',
     };
-      ldap
+    try {
-        .validateAuthData({ id: 'testuser', password: 'wrong!' }, options)
+      await ldap.validateAuthData({ id: 'testuser', password: 'wrong!' }, options);
-        .then(done.fail)
+      fail();
-        .catch(err => {
+    } catch (err) {
-          jequal(err.message, 'LDAP: Wrong username or password');
+      expect(err.message).toBe('LDAP: Wrong username or password');
-          done();
+    }
-        })
+    server.close(done);
-        .finally(() => server.close());
-    });
   });
 
-  it('Should succeed if user is in given group', done => {
+  it('Should succeed if user is in given group', async done => {
-    mockLdapServer(port, 'uid=testuser, o=example').then(server => {
+    const server = await mockLdapServer(port, 'uid=testuser, o=example');
     const options = {
       suffix: 'o=example',
       url: `ldap://localhost:${port}`,
@@ -140,17 +122,12 @@ describe('Ldap Auth', () => {
       groupCn: 'powerusers',
       groupFilter: '(&(uniqueMember=uid={{id}}, o=example)(objectClass=groupOfUniqueNames))',
     };
-
+    await ldap.validateAuthData({ id: 'testuser', password: 'secret' }, options);
-      ldap
+    server.close(done);
-        .validateAuthData({ id: 'testuser', password: 'secret' }, options)
-        .then(done)
-        .catch(done.fail)
-        .finally(() => server.close());
-    });
   });
 
-  it('Should fail if user is not in given group', done => {
+  it('Should fail if user is not in given group', async done => {
-    mockLdapServer(port, 'uid=testuser, o=example').then(server => {
+    const server = await mockLdapServer(port, 'uid=testuser, o=example');
     const options = {
       suffix: 'o=example',
       url: `ldap://localhost:${port}`,
@@ -158,20 +135,17 @@ describe('Ldap Auth', () => {
       groupCn: 'groupTheUserIsNotIn',
       groupFilter: '(&(uniqueMember=uid={{id}}, o=example)(objectClass=groupOfUniqueNames))',
     };
-
+    try {
-      ldap
+      await ldap.validateAuthData({ id: 'testuser', password: 'secret' }, options);
-        .validateAuthData({ id: 'testuser', password: 'secret' }, options)
+      fail();
-        .then(done.fail)
+    } catch (err) {
-        .catch(err => {
+      expect(err.message).toBe('LDAP: User not in group');
-          jequal(err.message, 'LDAP: User not in group');
+    }
-          done();
+    server.close(done);
-        })
-        .finally(() => server.close());
-    });
   });
 
-  it('Should fail if the LDAP server does not allow searching inside the provided suffix', done => {
+  it('Should fail if the LDAP server does not allow searching inside the provided suffix', async done => {
-    mockLdapServer(port, 'uid=testuser, o=example').then(server => {
+    const server = await mockLdapServer(port, 'uid=testuser, o=example');
     const options = {
       suffix: 'o=invalid',
       url: `ldap://localhost:${port}`,
@@ -179,20 +153,17 @@ describe('Ldap Auth', () => {
       groupCn: 'powerusers',
       groupFilter: '(&(uniqueMember=uid={{id}}, o=example)(objectClass=groupOfUniqueNames))',
     };
-
+    try {
-      ldap
+      await ldap.validateAuthData({ id: 'testuser', password: 'secret' }, options);
-        .validateAuthData({ id: 'testuser', password: 'secret' }, options)
+      fail();
-        .then(done.fail)
+    } catch (err) {
-        .catch(err => {
+      expect(err.message).toBe('LDAP group search failed');
-          jequal(err.message, 'LDAP group search failed');
+    }
-          done();
+    server.close(done);
-        })
-        .finally(() => server.close());
-    });
   });
 
-  it('Should fail if the LDAP server encounters an error while searching', done => {
+  it('Should fail if the LDAP server encounters an error while searching', async done => {
-    mockLdapServer(port, 'uid=testuser, o=example', true).then(server => {
+    const server = await mockLdapServer(port, 'uid=testuser, o=example', true);
     const options = {
       suffix: 'o=example',
       url: `ldap://localhost:${port}`,
@@ -200,62 +171,42 @@ describe('Ldap Auth', () => {
       groupCn: 'powerusers',
       groupFilter: '(&(uniqueMember=uid={{id}}, o=example)(objectClass=groupOfUniqueNames))',
     };
-
+    try {
-      ldap
+      await ldap.validateAuthData({ id: 'testuser', password: 'secret' }, options);
-        .validateAuthData({ id: 'testuser', password: 'secret' }, options)
+      fail();
-        .then(done.fail)
+    } catch (err) {
-        .catch(err => {
+      expect(err.message).toBe('LDAP group search failed');
-          jequal(err.message, 'LDAP group search failed');
+    }
-          done();
+    server.close(done);
-        })
-        .finally(() => server.close());
-    });
   });
 
-  it('Should delete the password from authData after validation', done => {
+  it('Should delete the password from authData after validation', async done => {
-    mockLdapServer(port, 'uid=testuser, o=example', true).then(server => {
+    const server = await mockLdapServer(port, 'uid=testuser, o=example', true);
     const options = {
       suffix: 'o=example',
       url: `ldap://localhost:${port}`,
       dn: 'uid={{id}}, o=example',
     };
-
     const authData = { id: 'testuser', password: 'secret' };
-
+    await ldap.validateAuthData(authData, options);
-      ldap
-        .validateAuthData(authData, options)
-        .then(() => {
     expect(authData).toEqual({ id: 'testuser' });
-          done();
+    server.close(done);
-        })
-        .catch(done.fail)
-        .finally(() => server.close());
-    });
   });
 
-  it('Should not save the password in the user record after authentication', done => {
+  it('Should not save the password in the user record after authentication', async done => {
-    mockLdapServer(port, 'uid=testuser, o=example', true).then(server => {
+    const server = await mockLdapServer(port, 'uid=testuser, o=example', true);
     const options = {
       suffix: 'o=example',
       url: `ldap://localhost:${port}`,
       dn: 'uid={{id}}, o=example',
     };
-      reconfigureServer({ auth: { ldap: options } }).then(() => {
+    await reconfigureServer({ auth: { ldap: options } });
     const authData = { authData: { id: 'testuser', password: 'secret' } };
-        Parse.User.logInWith('ldap', authData).then(returnedUser => {
+    const returnedUser = await Parse.User.logInWith('ldap', authData);
     const query = new Parse.Query('User');
-          query
+    const user = await query.equalTo('objectId', returnedUser.id).first({ useMasterKey: true });
-            .equalTo('objectId', returnedUser.id)
-            .first({ useMasterKey: true })
-            .then(user => {
     expect(user.get('authData')).toEqual({ ldap: { id: 'testuser' } });
     expect(user.get('authData').ldap.password).toBeUndefined();
-              done();
+    server.close(done);
-            })
-            .catch(done.fail)
-            .finally(() => server.close());
-        });
-      });
-    });
   });
 });

spec/LoggerController.spec.js

@@ -70,6 +70,7 @@ describe('LoggerController', () => {
     };
 
     const loggerController = new LoggerController(new WinstonLoggerAdapter());
+    loggerController.error('can process an ascending query without throwing');
 
     expect(() => {
       loggerController
@@ -115,6 +116,7 @@ describe('LoggerController', () => {
     };
 
     const loggerController = new LoggerController(new WinstonLoggerAdapter());
+    loggerController.error('can process a descending query without throwing');
 
     expect(() => {
       loggerController

spec/Parse.Push.spec.js

@@ -2,10 +2,15 @@
 
 const request = require('../lib/request');
 
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+
 const pushCompleted = async pushId => {
-  let result = await Parse.Push.getPushStatus(pushId);
+  const query = new Parse.Query('_PushStatus');
+  query.equalTo('objectId', pushId);
+  let result = await query.first({ useMasterKey: true });
   while (!(result && result.get('status') === 'succeeded')) {
-    result = await Parse.Push.getPushStatus(pushId);
+    await sleep(100);
+    result = await query.first({ useMasterKey: true });
   }
 };
 

spec/ParseGraphQLServer.spec.js

@@ -5,7 +5,7 @@ const fetch = require('node-fetch');
 const FormData = require('form-data');
 const ws = require('ws');
 require('./helper');
-const { updateCLP } = require('./dev');
+const { updateCLP } = require('./support/dev');
 
 const pluralize = require('pluralize');
 const { getMainDefinition } = require('apollo-utilities');
@@ -9033,7 +9033,7 @@ describe('ParseGraphQLServer', () => {
 
         it('should support object values', async () => {
           try {
-            const someFieldValue = {
+            const someObjectFieldValue = {
               foo: { bar: 'baz' },
               number: 10,
             };
@@ -9048,7 +9048,7 @@ describe('ParseGraphQLServer', () => {
               `,
               variables: {
                 schemaFields: {
-                  addObjects: [{ name: 'someField' }],
+                  addObjects: [{ name: 'someObjectField' }],
                 },
               },
               context: {
@@ -9057,11 +9057,10 @@ describe('ParseGraphQLServer', () => {
                 },
               },
             });
-
             await parseGraphQLServer.parseGraphQLSchema.databaseController.schemaCache.clear();
 
             const schema = await new Parse.Schema('SomeClass').get();
-            expect(schema.fields.someField.type).toEqual('Object');
+            expect(schema.fields.someObjectField.type).toEqual('Object');
 
             const createResult = await apolloClient.mutate({
               mutation: gql`
@@ -9075,13 +9074,13 @@ describe('ParseGraphQLServer', () => {
               `,
               variables: {
                 fields: {
-                  someField: someFieldValue,
+                  someObjectField: someObjectFieldValue,
                 },
               },
             });
 
             const where = {
-              someField: {
+              someObjectField: {
                 equalTo: { key: 'foo.bar', value: 'baz' },
                 notEqualTo: { key: 'foo.bar', value: 'bat' },
                 greaterThan: { key: 'number', value: 9 },
@@ -9093,13 +9092,13 @@ describe('ParseGraphQLServer', () => {
                 query GetSomeObject($id: ID!, $where: SomeClassWhereInput) {
                   someClass(id: $id) {
                     id
-                    someField
+                    someObjectField
                   }
                   someClasses(where: $where) {
                     edges {
                       node {
                         id
-                        someField
+                        someObjectField
                       }
                     }
                   }
@@ -9113,13 +9112,13 @@ describe('ParseGraphQLServer', () => {
 
             const { someClass: getResult, someClasses } = queryResult.data;
 
-            const { someField } = getResult;
+            const { someObjectField } = getResult;
-            expect(typeof someField).toEqual('object');
+            expect(typeof someObjectField).toEqual('object');
-            expect(someField).toEqual(someFieldValue);
+            expect(someObjectField).toEqual(someObjectFieldValue);
 
             // Checks class query results
             expect(someClasses.edges.length).toEqual(1);
-            expect(someClasses.edges[0].node.someField).toEqual(someFieldValue);
+            expect(someClasses.edges[0].node.someObjectField).toEqual(someObjectFieldValue);
           } catch (e) {
             handleError(e);
           }
@@ -9127,11 +9126,11 @@ describe('ParseGraphQLServer', () => {
 
         it('should support object composed queries', async () => {
           try {
-            const someFieldValue = {
+            const someObjectFieldValue1 = {
               lorem: 'ipsum',
               number: 10,
             };
-            const someFieldValue2 = {
+            const someObjectFieldValue2 = {
               foo: {
                 test: 'bar',
               },
@@ -9144,7 +9143,7 @@ describe('ParseGraphQLServer', () => {
                   createClass(
                     input: {
                       name: "SomeClass"
-                      schemaFields: { addObjects: [{ name: "someField" }] }
+                      schemaFields: { addObjects: [{ name: "someObjectField" }] }
                     }
                   ) {
                     clientMutationId
@@ -9180,10 +9179,10 @@ describe('ParseGraphQLServer', () => {
               `,
               variables: {
                 fields1: {
-                  someField: someFieldValue,
+                  someObjectField: someObjectFieldValue1,
                 },
                 fields2: {
-                  someField: someFieldValue2,
+                  someObjectField: someObjectFieldValue2,
                 },
               },
             });
@@ -9191,24 +9190,24 @@ describe('ParseGraphQLServer', () => {
             const where = {
               AND: [
                 {
-                  someField: {
+                  someObjectField: {
                     greaterThan: { key: 'number', value: 9 },
                   },
                 },
                 {
-                  someField: {
+                  someObjectField: {
                     lessThan: { key: 'number', value: 11 },
                   },
                 },
                 {
                   OR: [
                     {
-                      someField: {
+                      someObjectField: {
                         equalTo: { key: 'lorem', value: 'ipsum' },
                       },
                     },
                     {
-                      someField: {
+                      someObjectField: {
                         equalTo: { key: 'foo.test', value: 'bar' },
                       },
                     },
@@ -9223,7 +9222,7 @@ describe('ParseGraphQLServer', () => {
                     edges {
                       node {
                         id
-                        someField
+                        someObjectField
                       }
                     }
                   }
@@ -9241,11 +9240,11 @@ describe('ParseGraphQLServer', () => {
             const { edges } = someClasses;
             expect(edges.length).toEqual(2);
             expect(
-              edges.find(result => result.node.id === create1.someClass.id).node.someField
+              edges.find(result => result.node.id === create1.someClass.id).node.someObjectField
-            ).toEqual(someFieldValue);
+            ).toEqual(someObjectFieldValue1);
             expect(
-              edges.find(result => result.node.id === create2.someClass.id).node.someField
+              edges.find(result => result.node.id === create2.someClass.id).node.someObjectField
-            ).toEqual(someFieldValue2);
+            ).toEqual(someObjectFieldValue2);
           } catch (e) {
             handleError(e);
           }
@@ -9253,7 +9252,7 @@ describe('ParseGraphQLServer', () => {
 
         it('should support array values', async () => {
           try {
-            const someFieldValue = [1, 'foo', ['bar'], { lorem: 'ipsum' }, true];
+            const someArrayFieldValue = [1, 'foo', ['bar'], { lorem: 'ipsum' }, true];
 
             await apolloClient.mutate({
               mutation: gql`
@@ -9265,7 +9264,7 @@ describe('ParseGraphQLServer', () => {
               `,
               variables: {
                 schemaFields: {
-                  addArrays: [{ name: 'someField' }],
+                  addArrays: [{ name: 'someArrayField' }],
                 },
               },
               context: {
@@ -9278,7 +9277,7 @@ describe('ParseGraphQLServer', () => {
             await parseGraphQLServer.parseGraphQLSchema.databaseController.schemaCache.clear();
 
             const schema = await new Parse.Schema('SomeClass').get();
-            expect(schema.fields.someField.type).toEqual('Array');
+            expect(schema.fields.someArrayField.type).toEqual('Array');
 
             const createResult = await apolloClient.mutate({
               mutation: gql`
@@ -9292,7 +9291,7 @@ describe('ParseGraphQLServer', () => {
               `,
               variables: {
                 fields: {
-                  someField: someFieldValue,
+                  someArrayField: someArrayFieldValue,
                 },
               },
             });
@@ -9301,17 +9300,17 @@ describe('ParseGraphQLServer', () => {
               query: gql`
                 query GetSomeObject($id: ID!) {
                   someClass(id: $id) {
-                    someField {
+                    someArrayField {
                       ... on Element {
                         value
                       }
                     }
                   }
-                  someClasses(where: { someField: { exists: true } }) {
+                  someClasses(where: { someArrayField: { exists: true } }) {
                     edges {
                       node {
                         id
-                        someField {
+                        someArrayField {
                           ... on Element {
                             value
                           }
@@ -9326,9 +9325,9 @@ describe('ParseGraphQLServer', () => {
               },
             });
 
-            const { someField } = getResult.data.someClass;
+            const { someArrayField } = getResult.data.someClass;
-            expect(Array.isArray(someField)).toBeTruthy();
+            expect(Array.isArray(someArrayField)).toBeTruthy();
-            expect(someField.map(element => element.value)).toEqual(someFieldValue);
+            expect(someArrayField.map(element => element.value)).toEqual(someArrayFieldValue);
             expect(getResult.data.someClasses.edges.length).toEqual(1);
           } catch (e) {
             handleError(e);
@@ -10201,7 +10200,6 @@ describe('ParseGraphQLServer', () => {
       let apolloClient;
 
       beforeEach(async () => {
-        if (!httpServer) {
         const expressApp = express();
         httpServer = http.createServer(expressApp);
         const TypeEnum = new GraphQLEnumType({
@@ -10292,10 +10290,9 @@ describe('ParseGraphQLServer', () => {
             },
           },
         });
-        }
       });
 
-      afterAll(async () => {
+      afterEach(async () => {
         await httpServer.close();
       });
 

spec/ParseHooks.spec.js

@@ -8,9 +8,8 @@ const bodyParser = require('body-parser');
 const auth = require('../lib/Auth');
 const Config = require('../lib/Config');
 
-const port = 12345;
+const port = 34567;
 const hookServerURL = 'http://localhost:' + port;
-const AppCache = require('../lib/cache').AppCache;
 
 describe('Hooks', () => {
   let server;
@@ -19,7 +18,7 @@ describe('Hooks', () => {
     if (!app) {
       app = express();
       app.use(bodyParser.json({ type: '*/*' }));
-      server = app.listen(12345, undefined, done);
+      server = app.listen(port, undefined, done);
     } else {
       done();
     }
@@ -383,7 +382,7 @@ describe('Hooks', () => {
           }
           const hooksController = new HooksController(
             Parse.applicationId,
-            AppCache.get('test').databaseController
+            Config.get('test').database
           );
           return hooksController.load();
         },

spec/ParseLiveQueryServer.spec.js

@@ -127,7 +127,10 @@ describe('ParseLiveQueryServer', function () {
         serverStartComplete: () => {
           expect(parseServer.liveQueryServer).not.toBeUndefined();
           expect(parseServer.liveQueryServer.server).toBe(parseServer.server);
-          parseServer.server.close(done);
+          parseServer.server.close(async () => {
+            await reconfigureServer();
+            done();
+          });
         },
       });
     });
@@ -149,7 +152,10 @@ describe('ParseLiveQueryServer', function () {
           expect(parseServer.liveQueryServer).not.toBeUndefined();
           expect(parseServer.liveQueryServer.server).not.toBe(parseServer.server);
           parseServer.liveQueryServer.server.close(
-            parseServer.server.close.bind(parseServer.server, done)
+            parseServer.server.close.bind(parseServer.server, async () => {
+              await reconfigureServer();
+              done();
+            })
           );
         },
       });

spec/ParseServerRESTController.spec.js

@@ -169,25 +169,25 @@ describe('ParseServerRESTController', () => {
     process.env.PARSE_SERVER_TEST_DB === 'postgres'
   ) {
     describe('transactions', () => {
-      let parseServer;
       beforeEach(async () => {
+        await TestUtils.destroyAllDataPermanently(true);
         if (
           semver.satisfies(process.env.MONGODB_VERSION, '>=4.0.4') &&
           process.env.MONGODB_TOPOLOGY === 'replicaset' &&
           process.env.MONGODB_STORAGE_ENGINE === 'wiredTiger'
         ) {
-          if (!parseServer) {
+          await reconfigureServer({
-            parseServer = await reconfigureServer({
             databaseAdapter: undefined,
             databaseURI:
               'mongodb://localhost:27017/parseServerMongoAdapterTestDatabase?replicaSet=replicaset',
           });
-          }
+        } else {
-          await TestUtils.destroyAllDataPermanently(true);
+          await reconfigureServer();
         }
       });
 
-      it('should handle a batch request with transaction = true', done => {
+      it('should handle a batch request with transaction = true', async done => {
+        await reconfigureServer();
         const myObject = new Parse.Object('MyObject'); // This is important because transaction only works on pre-existing collections
         myObject
           .save()
@@ -236,15 +236,12 @@ describe('ParseServerRESTController', () => {
           .catch(done.fail);
       });
 
-      it('should not save anything when one operation fails in a transaction', done => {
+      it('should not save anything when one operation fails in a transaction', async () => {
         const myObject = new Parse.Object('MyObject'); // This is important because transaction only works on pre-existing collections
-        myObject
+        await myObject.save();
-          .save()
+        await myObject.destroy();
-          .then(() => {
+        try {
-            return myObject.destroy();
+          await RESTController.request('POST', 'batch', {
-          })
-          .then(() => {
-            RESTController.request('POST', 'batch', {
             requests: [
               {
                 method: 'POST',
@@ -338,15 +335,14 @@ describe('ParseServerRESTController', () => {
               },
             ],
             transaction: true,
-            }).catch(error => {
+          });
+          fail();
+        } catch (error) {
           expect(error).toBeDefined();
           const query = new Parse.Query('MyObject');
-              query.find().then(results => {
+          const results = await query.find();
           expect(results.length).toBe(0);
-                done();
+        }
-              });
-            });
-          });
       });
 
       it('should generate separate session for each call', async () => {

spec/PostgresInitOptions.spec.js

@@ -28,7 +28,7 @@ function createParseServer(options) {
   return new Promise((resolve, reject) => {
     const parseServer = new ParseServer.default(
       Object.assign({}, defaultConfiguration, options, {
-        serverURL: 'http://localhost:12666/parse',
+        serverURL: 'http://localhost:12668/parse',
         serverStartComplete: error => {
           if (error) {
             reject(error);
@@ -37,8 +37,8 @@ function createParseServer(options) {
             const app = express();
             app.use('/parse', parseServer.app);
 
-            const server = app.listen(12666);
+            const server = app.listen(12668);
-            Parse.serverURL = 'http://localhost:12666/parse';
+            Parse.serverURL = 'http://localhost:12668/parse';
             resolve(server);
           }
         },

spec/ProtectedFields.spec.js

@@ -1,7 +1,7 @@
 const Config = require('../lib/Config');
 const Parse = require('parse/node');
 const request = require('../lib/request');
-const { className, createRole, createUser, logIn, updateCLP } = require('./dev');
+const { className, createRole, createUser, logIn, updateCLP } = require('./support/dev');
 
 describe('ProtectedFields', function () {
   it('should handle and empty protectedFields', async function () {

spec/PushController.spec.js

@@ -26,10 +26,15 @@ const successfulIOS = function (body, installations) {
   return Promise.all(promises);
 };
 
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+
 const pushCompleted = async pushId => {
-  let result = await Parse.Push.getPushStatus(pushId);
+  const query = new Parse.Query('_PushStatus');
+  query.equalTo('objectId', pushId);
+  let result = await query.first({ useMasterKey: true });
   while (!(result && result.get('status') === 'succeeded')) {
-    result = await Parse.Push.getPushStatus(pushId);
+    await sleep(100);
+    result = await query.first({ useMasterKey: true });
   }
 };
 
@@ -568,7 +573,7 @@ describe('PushController', () => {
     await pushCompleted(pushStatusId);
   });
 
-  it('should properly report failures in _PushStatus', done => {
+  it('should properly report failures in _PushStatus', async () => {
     const pushAdapter = {
       send: function (body, installations) {
         return installations.map(installation => {
@@ -593,30 +598,27 @@ describe('PushController', () => {
         badge: 1,
       },
     };
-    const config = Config.get(Parse.applicationId);
     const auth = {
       isMaster: true,
     };
     const pushController = new PushController();
-    reconfigureServer({
+    await reconfigureServer({
       push: { adapter: pushAdapter },
-    })
+    });
-      .then(() => {
+    const config = Config.get(Parse.applicationId);
-        return pushController.sendPush(payload, where, config, auth);
+    try {
-      })
+      await pushController.sendPush(payload, where, config, auth);
-      .then(() => {
+      fail();
-        fail('should not succeed');
+    } catch (e) {
-        done();
-      })
-      .catch(() => {
       const query = new Parse.Query('_PushStatus');
-        query.find({ useMasterKey: true }).then(results => {
+      let results = await query.find({ useMasterKey: true });
+      while (results.length === 0) {
+        results = await query.find({ useMasterKey: true });
+      }
       expect(results.length).toBe(1);
       const pushStatus = results[0];
       expect(pushStatus.get('status')).toBe('failed');
-          done();
+    }
-        });
-      });
   });
 
   it('should support full RESTQuery for increment', async () => {
@@ -1237,7 +1239,7 @@ describe('PushController', () => {
     const auth = { isMaster: true };
     const pushController = new PushController();
 
-    let config = Config.get(Parse.applicationId);
+    let config;
 
     const pushes = [];
     const pushAdapter = {

spec/RedisCacheAdapter.spec.js

@@ -1,6 +1,11 @@
 const RedisCacheAdapter = require('../lib/Adapters/Cache/RedisCacheAdapter').default;
 const Config = require('../lib/Config');
 
+function wait(sleep) {
+  return new Promise(function (resolve) {
+    setTimeout(resolve, sleep);
+  });
+}
 /*
 To run this test part of the complete suite
 set PARSE_SERVER_TEST_CACHE='redis'
@@ -11,31 +16,30 @@ describe_only(() => {
 })('RedisCacheAdapter', function () {
   const KEY = 'hello';
   const VALUE = 'world';
+  let cache;
 
-  function wait(sleep) {
+  beforeEach(async () => {
-    return new Promise(function (resolve) {
+    cache = new RedisCacheAdapter(null, 100);
-      setTimeout(resolve, sleep);
+    await cache.clear();
   });
-  }
 
   it('should get/set/clear', done => {
-    const cache = new RedisCacheAdapter({
+    const cacheNaN = new RedisCacheAdapter({
       ttl: NaN,
     });
 
-    cache
+    cacheNaN
       .put(KEY, VALUE)
-      .then(() => cache.get(KEY))
+      .then(() => cacheNaN.get(KEY))
       .then(value => expect(value).toEqual(VALUE))
-      .then(() => cache.clear())
+      .then(() => cacheNaN.clear())
-      .then(() => cache.get(KEY))
+      .then(() => cacheNaN.get(KEY))
       .then(value => expect(value).toEqual(null))
+      .then(() => cacheNaN.clear())
       .then(done);
   });
 
   it('should expire after ttl', done => {
-    const cache = new RedisCacheAdapter(null, 100);
-
     cache
       .put(KEY, VALUE)
       .then(() => cache.get(KEY))
@@ -47,8 +51,6 @@ describe_only(() => {
   });
 
   it('should not store value for ttl=0', done => {
-    const cache = new RedisCacheAdapter(null, 100);
-
     cache
       .put(KEY, VALUE, 0)
       .then(() => cache.get(KEY))
@@ -57,8 +59,6 @@ describe_only(() => {
   });
 
   it('should not expire when ttl=Infinity', done => {
-    const cache = new RedisCacheAdapter(null, 100);
-
     cache
       .put(KEY, VALUE, Infinity)
       .then(() => cache.get(KEY))
@@ -70,7 +70,6 @@ describe_only(() => {
   });
 
   it('should fallback to default ttl', done => {
-    const cache = new RedisCacheAdapter(null, 100);
     let promise = Promise.resolve();
 
     [-100, null, undefined, 'not number', true].forEach(ttl => {
@@ -89,8 +88,6 @@ describe_only(() => {
   });
 
   it('should find un-expired records', done => {
-    const cache = new RedisCacheAdapter(null, 100);
-
     cache
       .put(KEY, VALUE)
       .then(() => cache.get(KEY))
@@ -102,8 +99,6 @@ describe_only(() => {
   });
 
   it('handleShutdown, close connection', async () => {
-    const cache = new RedisCacheAdapter(null, 100);
-
     await cache.handleShutdown();
     setTimeout(() => {
       expect(cache.client.connected).toBe(false);

spec/UserController.spec.js

@@ -1,6 +1,5 @@
 const UserController = require('../lib/Controllers/UserController').UserController;
-const emailAdapter = require('./MockEmailAdapter');
+const emailAdapter = require('./support/MockEmailAdapter');
-const AppCache = require('../lib/cache').AppCache;
 
 describe('UserController', () => {
   const user = {
@@ -11,55 +10,45 @@ describe('UserController', () => {
 
   describe('sendVerificationEmail', () => {
     describe('parseFrameURL not provided', () => {
-      it('uses publicServerURL', done => {
+      it('uses publicServerURL', async done => {
-        AppCache.put(
+        await reconfigureServer({
-          defaultConfiguration.appId,
-          Object.assign({}, defaultConfiguration, {
           publicServerURL: 'http://www.example.com',
           customPages: {
             parseFrameURL: undefined,
           },
-          })
+        });
-        );
-
         emailAdapter.sendVerificationEmail = options => {
           expect(options.link).toEqual(
             'http://www.example.com/apps/test/verify_email?token=testToken&username=testUser'
           );
+          emailAdapter.sendVerificationEmail = () => Promise.resolve();
           done();
         };
-
         const userController = new UserController(emailAdapter, 'test', {
           verifyUserEmails: true,
         });
-
         userController.sendVerificationEmail(user);
       });
     });
 
     describe('parseFrameURL provided', () => {
-      it('uses parseFrameURL and includes the destination in the link parameter', done => {
+      it('uses parseFrameURL and includes the destination in the link parameter', async done => {
-        AppCache.put(
+        await reconfigureServer({
-          defaultConfiguration.appId,
-          Object.assign({}, defaultConfiguration, {
           publicServerURL: 'http://www.example.com',
           customPages: {
             parseFrameURL: 'http://someother.example.com/handle-parse-iframe',
           },
-          })
+        });
-        );
-
         emailAdapter.sendVerificationEmail = options => {
           expect(options.link).toEqual(
             'http://someother.example.com/handle-parse-iframe?link=%2Fapps%2Ftest%2Fverify_email&token=testToken&username=testUser'
           );
+          emailAdapter.sendVerificationEmail = () => Promise.resolve();
           done();
         };
-
         const userController = new UserController(emailAdapter, 'test', {
           verifyUserEmails: true,
         });
-
         userController.sendVerificationEmail(user);
       });
     });

spec/ValidationAndPasswordsReset.spec.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const MockEmailAdapterWithOptions = require('./MockEmailAdapterWithOptions');
+const MockEmailAdapterWithOptions = require('./support/MockEmailAdapterWithOptions');
 const request = require('../lib/request');
 const Config = require('../lib/Config');
 

spec/VerifyUserPassword.spec.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const request = require('../lib/request');
-const MockEmailAdapterWithOptions = require('./MockEmailAdapterWithOptions');
+const MockEmailAdapterWithOptions = require('./support/MockEmailAdapterWithOptions');
 
 const verifyPassword = function (login, password, isEmail = false) {
   const body = !isEmail ? { username: login, password } : { email: login, password };

spec/batch.spec.js

@@ -175,6 +175,7 @@ describe('batch', () => {
   ) {
     describe('transactions', () => {
       beforeEach(async () => {
+        await TestUtils.destroyAllDataPermanently(true);
         if (
           semver.satisfies(process.env.MONGODB_VERSION, '>=4.0.4') &&
           process.env.MONGODB_TOPOLOGY === 'replicaset' &&
@@ -185,7 +186,8 @@ describe('batch', () => {
             databaseURI:
               'mongodb://localhost:27017/parseServerMongoAdapterTestDatabase?replicaSet=replicaset',
           });
-          await TestUtils.destroyAllDataPermanently(true);
+        } else {
+          await reconfigureServer();
         }
       });
 
@@ -243,15 +245,12 @@ describe('batch', () => {
           });
       });
 
-      it('should not save anything when one operation fails in a transaction', done => {
+      it('should not save anything when one operation fails in a transaction', async () => {
         const myObject = new Parse.Object('MyObject'); // This is important because transaction only works on pre-existing collections
-        myObject
+        await myObject.save();
-          .save()
+        await myObject.destroy();
-          .then(() => {
+        try {
-            return myObject.destroy();
+          await request({
-          })
-          .then(() => {
-            request({
             method: 'POST',
             headers: headers,
             url: 'http://localhost:8378/1/batch',
@@ -350,15 +349,13 @@ describe('batch', () => {
               ],
               transaction: true,
             }),
-            }).catch(error => {
+          });
-              expect(error.data).toBeDefined();
+        } catch (error) {
+          expect(error).toBeDefined();
           const query = new Parse.Query('MyObject');
-              query.find().then(results => {
+          const results = await query.find();
           expect(results.length).toBe(0);
-                done();
+        }
-              });
-            });
-          });
       });
 
       it('should generate separate session for each call', async () => {

spec/helper.js

@@ -1,14 +1,12 @@
 'use strict';
 const semver = require('semver');
 const CurrentSpecReporter = require('./support/CurrentSpecReporter.js');
+const { SpecReporter } = require('jasmine-spec-reporter');
 
 // Sets up a Parse API server for testing.
 jasmine.DEFAULT_TIMEOUT_INTERVAL = process.env.PARSE_SERVER_TEST_TIMEOUT || 10000;
 jasmine.getEnv().addReporter(new CurrentSpecReporter());
-if (process.env.PARSE_SERVER_LOG_LEVEL === 'debug') {
-  const { SpecReporter } = require('jasmine-spec-reporter');
 jasmine.getEnv().addReporter(new SpecReporter());
-}
 
 global.on_db = (db, callback, elseCallback) => {
   if (process.env.PARSE_SERVER_TEST_DB == db) {
@@ -28,6 +26,7 @@ if (global._babelPolyfill) {
 process.noDeprecation = true;
 
 const cache = require('../lib/cache').default;
+const defaults = require('../lib/defaults').default;
 const ParseServer = require('../lib/index').ParseServer;
 const path = require('path');
 const TestUtils = require('../lib/TestUtils');
@@ -113,7 +112,7 @@ const defaultConfiguration = {
     custom: mockCustom(),
     facebook: mockFacebook(),
     myoauth: {
-      module: path.resolve(__dirname, 'myoauth'), // relative path as it's run from src
+      module: path.resolve(__dirname, 'support/myoauth'), // relative path as it's run from src
     },
     shortLivedAuth: mockShortLivedAuth(),
   },
@@ -124,6 +123,16 @@ if (process.env.PARSE_SERVER_TEST_CACHE === 'redis') {
 }
 
 const openConnections = {};
+const destroyAliveConnections = function () {
+  for (const socketId in openConnections) {
+    try {
+      openConnections[socketId].destroy();
+      delete openConnections[socketId];
+    } catch (e) {
+      /* */
+    }
+  }
+};
 // Set up a default API server for testing with default configuration.
 let server;
 
@@ -146,7 +155,6 @@ const reconfigureServer = (changedConfiguration = {}) => {
           if (error) {
             reject(error);
           } else {
-            Parse.CoreManager.set('REQUEST_ATTEMPT_LIMIT', 1);
             resolve(parseServer);
           }
         },
@@ -194,8 +202,9 @@ beforeAll(async () => {
 afterEach(function (done) {
   const afterLogOut = async () => {
     if (Object.keys(openConnections).length > 0) {
-      fail('There were open connections to the server left after the test finished');
+      console.warn('There were open connections to the server left after the test finished');
     }
+    destroyAliveConnections();
     await TestUtils.destroyAllDataPermanently(true);
     if (didChangeConfiguration) {
       await reconfigureServer();
@@ -205,6 +214,7 @@ afterEach(function (done) {
     done();
   };
   Parse.Cloud._removeAllHooks();
+  defaults.protectedFields = { _User: { '*': ['email'] } };
   databaseAdapter
     .getAllClasses()
     .then(allSchemas => {

spec/index.spec.js

@@ -1,7 +1,7 @@
 'use strict';
 const request = require('../lib/request');
 const parseServerPackage = require('../package.json');
-const MockEmailAdapterWithOptions = require('./MockEmailAdapterWithOptions');
+const MockEmailAdapterWithOptions = require('./support/MockEmailAdapterWithOptions');
 const ParseServer = require('../lib/index');
 const Config = require('../lib/Config');
 const express = require('express');
@@ -317,10 +317,16 @@ describe('server', () => {
             })
             .then(obj => {
               expect(obj.id).toEqual(objId);
-              server.close(done);
+              server.close(async () => {
+                await reconfigureServer();
+                done();
+              });
             })
             .catch(() => {
-              server.close(done);
+              server.close(async () => {
+                await reconfigureServer();
+                done();
+              });
             });
         },
       })
@@ -354,12 +360,18 @@ describe('server', () => {
             })
             .then(obj => {
               expect(obj.id).toEqual(objId);
-              server.close(done);
+              server.close(async () => {
+                await reconfigureServer();
+                done();
+              });
             })
             .catch(error => {
               fail(JSON.stringify(error));
               if (server) {
-                server.close(done);
+                server.close(async () => {
+                  await reconfigureServer();
+                  done();
+                });
               } else {
                 done();
               }

spec/schemas.spec.js

@@ -1274,6 +1274,7 @@ describe('schemas', () => {
           },
         },
       }).then(response => {
+        delete response.data.indexes;
         expect(
           dd(response.data, {
             className: '_User',
@@ -1302,6 +1303,7 @@ describe('schemas', () => {
           headers: masterKeyHeaders,
           json: true,
         }).then(response => {
+          delete response.data.indexes;
           expect(
             dd(response.data, {
               className: '_User',

spec/support/MockLdapServer.js

@@ -2,8 +2,8 @@ const ldapjs = require('ldapjs');
 const fs = require('fs');
 
 const tlsOptions = {
-  key: fs.readFileSync(__dirname + '/support/cert/key.pem'),
+  key: fs.readFileSync(__dirname + '/cert/key.pem'),
-  certificate: fs.readFileSync(__dirname + '/support/cert/cert.pem'),
+  certificate: fs.readFileSync(__dirname + '/cert/cert.pem'),
 };
 
 function newServer(port, dn, provokeSearchError = false, ssl = false) {

spec/support/dev.js

@@ -1,4 +1,4 @@
-const Config = require('../lib/Config');
+const Config = require('../../lib/Config');
 const Parse = require('parse/node');
 
 const className = 'AnObject';

spec/support/jasmine.json

@@ -2,5 +2,5 @@
   "spec_dir": "spec",
   "spec_files": ["*spec.js"],
   "helpers": ["helper.js"],
-  "random": false
+  "random": true
 }

src/Adapters/Auth/ldap.js

@@ -95,6 +95,8 @@ function searchForGroup(client, options, id, resolve, reject) {
       }
     });
     res.on('error', () => {
+      client.unbind();
+      client.destroy();
       return reject(new Parse.Error(Parse.Error.INTERNAL_SERVER_ERROR, 'LDAP group search failed'));
     });
   });

src/Adapters/Cache/RedisCacheAdapter/index.js

@@ -5,8 +5,9 @@ import { KeyPromiseQueue } from './KeyPromiseQueue';
 const DEFAULT_REDIS_TTL = 30 * 1000; // 30 seconds in milliseconds
 const FLUSH_DB_KEY = '__flush_db__';
 
-function debug() {
+function debug(...args: any) {
-  logger.debug.apply(logger, ['RedisCacheAdapter', ...arguments]);
+  const message = ['RedisCacheAdapter: ' + arguments[0]].concat(args.slice(1, args.length));
+  logger.debug.apply(logger, message);
 }
 
 const isValidTTL = ttl => typeof ttl === 'number' && ttl > 0;
@@ -33,13 +34,13 @@ export class RedisCacheAdapter {
   }
 
   get(key) {
-    debug('get', key);
+    debug('get', { key });
     return this.queue.enqueue(
       key,
       () =>
         new Promise(resolve => {
           this.client.get(key, function (err, res) {
-            debug('-> get', key, res);
+            debug('-> get', { key, res });
             if (!res) {
               return resolve(null);
             }
@@ -51,7 +52,7 @@ export class RedisCacheAdapter {
 
   put(key, value, ttl = this.ttl) {
     value = JSON.stringify(value);
-    debug('put', key, value, ttl);
+    debug('put', { key, value, ttl });
 
     if (ttl === 0) {
       // ttl of zero is a logical no-op, but redis cannot set expire time of zero
@@ -86,7 +87,7 @@ export class RedisCacheAdapter {
   }
 
   del(key) {
-    debug('del', key);
+    debug('del', { key });
     return this.queue.enqueue(
       key,
       () =>

src/Controllers/SchemaController.js

@@ -1215,16 +1215,10 @@ export default class SchemaController {
     const promises = [];
 
     for (const fieldName in object) {
-      if (object[fieldName] === undefined) {
+      if (object[fieldName] && getType(object[fieldName]) === 'GeoPoint') {
-        continue;
-      }
-      const expected = getType(object[fieldName]);
-      if (expected === 'GeoPoint') {
         geocount++;
       }
       if (geocount > 1) {
-        // Make sure all field validation operations run before we return.
-        // If not - we are continuing to run logic, but already provided response from the server.
         return Promise.reject(
           new Parse.Error(
             Parse.Error.INCORRECT_TYPE,
@@ -1232,6 +1226,12 @@ export default class SchemaController {
           )
         );
       }
+    }
+    for (const fieldName in object) {
+      if (object[fieldName] === undefined) {
+        continue;
+      }
+      const expected = getType(object[fieldName]);
       if (!expected) {
         continue;
       }