test: Fix flaky tests (#10320)

Author: mtrezza

spec/ParseGraphQLController.spec.js

@@ -11,6 +11,8 @@ describe('ParseGraphQLController', () => {
   let databaseController;
   let cacheController;
   let databaseUpdateArgs;
+  let originalDbFind;
+  let originalDbUpdate;
 
   // Holds the graphQLConfig in memory instead of using the db
   let graphQLConfigRecord;
@@ -34,17 +36,18 @@ describe('ParseGraphQLController', () => {
       databaseController = parseServer.config.databaseController;
       cacheController = parseServer.config.cacheController;
 
-      const defaultFind = databaseController.find.bind(databaseController);
+      originalDbFind = databaseController.find.bind(databaseController);
+      originalDbUpdate = databaseController.update.bind(databaseController);
+
       databaseController.find = async (className, query, ...args) => {
         if (className === GraphQLConfigClassName && isEqual(query, { objectId: GraphQLConfigId })) {
           const graphQLConfigRecord = getConfigFromDb();
           return graphQLConfigRecord ? [graphQLConfigRecord] : [];
         } else {
-          return defaultFind(className, query, ...args);
+          return originalDbFind(className, query, ...args);
         }
       };
 
-      const defaultUpdate = databaseController.update.bind(databaseController);
       databaseController.update = async (className, query, update, fullQueryOptions) => {
         databaseUpdateArgs = [className, query, update, fullQueryOptions];
         if (
@@ -57,13 +60,20 @@ describe('ParseGraphQLController', () => {
         ) {
           setConfigOnDb(update[GraphQLConfigKey]);
         } else {
-          return defaultUpdate(...databaseUpdateArgs);
+          return originalDbUpdate(...databaseUpdateArgs);
         }
       };
     }
     databaseUpdateArgs = null;
   });
 
+  afterAll(() => {
+    if (databaseController) {
+      databaseController.find = originalDbFind;
+      databaseController.update = originalDbUpdate;
+    }
+  });
+
   describe('constructor', () => {
     it('should require a databaseController', () => {
       expect(() => new ParseGraphQLController()).toThrow(

spec/ParseGraphQLServer.spec.js

@@ -8658,6 +8658,13 @@ describe('ParseGraphQLServer', () => {
       });
 
       describe('Data Types', () => {
+        beforeEach(async () => {
+          const schema = new Parse.Schema('SomeClass');
+          await schema.purge().catch(() => {});
+          await schema.delete().catch(() => {});
+          await parseGraphQLServer.parseGraphQLSchema.schemaCache.clear();
+        });
+
         it('should support String', async () => {
           try {
             const someFieldValue = 'some string';
@@ -10423,6 +10430,7 @@ describe('ParseGraphQLServer', () => {
           schema.addPointer('somePointerField', 'SomeClass');
           schema.addRelation('someRelationField', 'SomeClass');
           await schema.save();
+          await parseGraphQLServer.parseGraphQLSchema.schemaCache.clear();
 
           const body = new FormData();
           body.append(

spec/rest.spec.js

@@ -653,7 +653,8 @@ describe('rest create', () => {
       password: 'zxcv',
       foo: 'bar',
     };
-    const now = new Date();
+    const defaultSessionLength = 1000 * 3600 * 24 * 365;
+    const before = Date.now();
 
     rest
       .create(config, auth.nobody(config), '_User', user)
@@ -670,10 +671,11 @@ describe('rest create', () => {
         expect(r.results.length).toEqual(1);
 
         const session = r.results[0];
-        const actual = new Date(session.expiresAt.iso);
-        const expected = new Date(now.getTime() + 1000 * 3600 * 24 * 365);
+        const actual = new Date(session.expiresAt.iso).getTime();
+        const after = Date.now();
 
-        expect(Math.abs(actual - expected) <= jasmine.DEFAULT_TIMEOUT_INTERVAL).toEqual(true);
+        expect(actual).toBeGreaterThanOrEqual(before + defaultSessionLength);
+        expect(actual).toBeLessThanOrEqual(after + defaultSessionLength);
 
         done();
       });
@@ -685,9 +687,9 @@ describe('rest create', () => {
       password: 'zxcv',
       foo: 'bar',
     };
-    const sessionLength = 3600, // 1 Hour ahead
-      now = new Date(); // For reference later
+    const sessionLength = 3600; // 1 Hour ahead
     config.sessionLength = sessionLength;
+    const before = Date.now();
 
     rest
       .create(config, auth.nobody(config), '_User', user)
@@ -704,10 +706,11 @@ describe('rest create', () => {
         expect(r.results.length).toEqual(1);
 
         const session = r.results[0];
-        const actual = new Date(session.expiresAt.iso);
-        const expected = new Date(now.getTime() + sessionLength * 1000);
+        const actual = new Date(session.expiresAt.iso).getTime();
+        const after = Date.now();
 
-        expect(Math.abs(actual - expected) <= jasmine.DEFAULT_TIMEOUT_INTERVAL).toEqual(true);
+        expect(actual).toBeGreaterThanOrEqual(before + sessionLength * 1000);
+        expect(actual).toBeLessThanOrEqual(after + sessionLength * 1000);
 
         done();
       })
@@ -717,38 +720,27 @@ describe('rest create', () => {
       });
   });
 
-  it('can create a session with no expiration', done => {
+  it('can create a session with no expiration', async () => {
+    await reconfigureServer({ expireInactiveSessions: false });
+    config = Config.get('test');
+
     const user = {
       username: 'asdf',
       password: 'zxcv',
       foo: 'bar',
     };
-    config.expireInactiveSessions = false;
-
-    rest
-      .create(config, auth.nobody(config), '_User', user)
-      .then(r => {
-        expect(Object.keys(r.response).length).toEqual(3);
-        expect(typeof r.response.objectId).toEqual('string');
-        expect(typeof r.response.createdAt).toEqual('string');
-        expect(typeof r.response.sessionToken).toEqual('string');
-        return rest.find(config, auth.master(config), '_Session', {
-          sessionToken: r.response.sessionToken,
-        });
-      })
-      .then(r => {
-        expect(r.results.length).toEqual(1);
 
-        const session = r.results[0];
-        expect(session.expiresAt).toBeUndefined();
+    const r = await rest.create(config, auth.nobody(config), '_User', user);
+    expect(Object.keys(r.response).length).toEqual(3);
+    expect(typeof r.response.objectId).toEqual('string');
+    expect(typeof r.response.createdAt).toEqual('string');
+    expect(typeof r.response.sessionToken).toEqual('string');
 
-        done();
-      })
-      .catch(err => {
-        console.error(err);
-        fail(err);
-        done();
-      });
+    const s = await rest.find(config, auth.master(config), '_Session', {
+      sessionToken: r.response.sessionToken,
+    });
+    expect(s.results.length).toEqual(1);
+    expect(s.results[0].expiresAt).toBeUndefined();
   });
 
   it('can create object in volatileClasses if masterKey', done => {