Fix jasmine 3.4 (#5573)

* Fix failing tests

* just ignore the test for now.

* Bumping jasmine

* Fix pg unhandled exception

* Improving the way the test is fixed

* Fix unhandled failed promise in postgres test

* Solving unhandled promise fail on redis test

* Returning the excluded test

* Fixing package-lock

* Fix unhandled promise from redis test

Author: davimacedo

package-lock.json

@@ -60,7 +60,7 @@
     "flow-bin": "0.98.1",
     "gaze": "1.1.3",
     "husky": "2.2.0",
-    "jasmine": "3.1.0",
+    "jasmine": "3.4.0",
     "jasmine-spec-reporter": "4.2.1",
     "jsdoc": "3.6.1",
     "jsdoc-babel": "0.5.0",

package.json

@@ -158,11 +158,14 @@ describe('ParseLiveQueryServer', function() {
           classNames: ['Yolo'],
         },
         startLiveQueryServer: true,
+        __indexBuildCompletionCallbackForTests: promise => {
+          promise.then(() => {
+            expect(parseServer.liveQueryServer).not.toBeUndefined();
+            expect(parseServer.liveQueryServer.server).toBe(parseServer.server);
+            parseServer.server.close(() => done());
+          });
+        },
       });
-
-      expect(parseServer.liveQueryServer).not.toBeUndefined();
-      expect(parseServer.liveQueryServer.server).toBe(parseServer.server);
-      parseServer.server.close(() => done());
     });
 
     it('can be initialized through ParseServer with liveQueryServerOptions', function(done) {
@@ -178,12 +181,18 @@ describe('ParseLiveQueryServer', function() {
         liveQueryServerOptions: {
           port: 22347,
         },
+        __indexBuildCompletionCallbackForTests: promise => {
+          promise.then(() => {
+            expect(parseServer.liveQueryServer).not.toBeUndefined();
+            expect(parseServer.liveQueryServer.server).not.toBe(
+              parseServer.server
+            );
+            parseServer.liveQueryServer.server.close(() => {
+              parseServer.server.close(() => done());
+            });
+          });
+        },
       });
-
-      expect(parseServer.liveQueryServer).not.toBeUndefined();
-      expect(parseServer.liveQueryServer.server).not.toBe(parseServer.server);
-      parseServer.liveQueryServer.server.close();
-      parseServer.server.close(() => done());
     });
   });
 

spec/ParseLiveQueryServer.spec.js

@@ -62,17 +62,20 @@ describe('Server Url Checks', () => {
     }
     const newConfiguration = Object.assign({}, defaultConfiguration, {
       databaseAdapter,
-    });
-    const parseServer = ParseServer.start(newConfiguration, () => {
-      parseServer.handleShutdown();
-      parseServer.server.close(err => {
-        if (err) {
-          done.fail('Close Server Error');
-        }
-        reconfigureServer({}).then(() => {
-          done();
+      __indexBuildCompletionCallbackForTests: promise => {
+        promise.then(() => {
+          parseServer.handleShutdown();
+          parseServer.server.close(err => {
+            if (err) {
+              done.fail('Close Server Error');
+            }
+            reconfigureServer({}).then(() => {
+              done();
+            });
+          });
         });
-      });
+      },
     });
+    const parseServer = ParseServer.start(newConfiguration);
   });
 });

spec/ParseServer.spec.js

@@ -440,13 +440,20 @@ describe('SchemaController', () => {
     // If two callers race to create the same schema, the response to the
     // race loser should be the same as if they hadn't been racing.
     config.database.loadSchema().then(schema => {
-      const p1 = schema.addClassIfNotExists('NewClass', {
-        foo: { type: 'String' },
-      });
-      const p2 = schema.addClassIfNotExists('NewClass', {
-        foo: { type: 'String' },
-      });
-      Promise.race([p1, p2]).then(actualSchema => {
+      const p1 = schema
+        .addClassIfNotExists('NewClass', {
+          foo: { type: 'String' },
+        })
+        .then(validateSchema)
+        .catch(validateError);
+      const p2 = schema
+        .addClassIfNotExists('NewClass', {
+          foo: { type: 'String' },
+        })
+        .then(validateSchema)
+        .catch(validateError);
+      let schemaValidated = false;
+      function validateSchema(actualSchema) {
         const expectedSchema = {
           className: 'NewClass',
           fields: {
@@ -467,10 +474,17 @@ describe('SchemaController', () => {
           },
         };
         expect(dd(actualSchema, expectedSchema)).toEqual(undefined);
-      });
-      Promise.all([p1, p2]).catch(error => {
+        schemaValidated = true;
+      }
+      let errorValidated = false;
+      function validateError(error) {
         expect(error.code).toEqual(Parse.Error.INVALID_CLASS_NAME);
         expect(error.message).toEqual('Class NewClass already exists.');
+        errorValidated = true;
+      }
+      Promise.all([p1, p2]).then(() => {
+        expect(schemaValidated).toEqual(true);
+        expect(errorValidated).toEqual(true);
         done();
       });
     });

spec/Schema.spec.js

@@ -97,11 +97,13 @@ class ParseServer {
 
     logging.setLogger(loggerController);
     const dbInitPromise = databaseController.performInitialization();
-    hooksController.load();
+    const hooksLoadPromise = hooksController.load();
 
     // Note: Tests will start to fail if any validation happens after this is called.
     if (process.env.TESTING) {
-      __indexBuildCompletionCallbackForTests(dbInitPromise);
+      __indexBuildCompletionCallbackForTests(
+        Promise.all([dbInitPromise, hooksLoadPromise])
+      );
     }
 
     if (cloud) {