skipWithMasterKey on Built-In Validator (#6972)

* Initial Commit

* Change to resolveMasterKey

* Change to skipWithMasterKey

spec/CloudCode.Validator.spec.js

@@ -554,6 +554,131 @@ describe('cloud validator', () => {
     done();
   });
 
+  it('basic beforeSave skipWithMasterKey', async function (done) {
+    Parse.Cloud.beforeSave(
+      'BeforeSave',
+      () => {
+        throw 'before save should have resolved using masterKey.';
+      },
+      {
+        skipWithMasterKey: true,
+      }
+    );
+    const obj = new Parse.Object('BeforeSave');
+    obj.set('foo', 'bar');
+    await obj.save(null, { useMasterKey: true });
+    expect(obj.get('foo')).toBe('bar');
+    done();
+  });
+
+  it('basic beforeFind skipWithMasterKey', async function (done) {
+    Parse.Cloud.beforeFind(
+      'beforeFind',
+      () => {
+        throw 'before find should have resolved using masterKey.';
+      },
+      {
+        skipWithMasterKey: true,
+      }
+    );
+    const obj = new Parse.Object('beforeFind');
+    obj.set('foo', 'bar');
+    await obj.save();
+    expect(obj.get('foo')).toBe('bar');
+
+    const query = new Parse.Query('beforeFind');
+    try {
+      const first = await query.first({ useMasterKey: true });
+      expect(first).toBeDefined();
+      expect(first.id).toBe(obj.id);
+      done();
+    } catch (e) {
+      console.log(e);
+      console.log(e.code);
+      throw e;
+    }
+  });
+
+  it('basic beforeDelete skipWithMasterKey', async function (done) {
+    Parse.Cloud.beforeDelete(
+      'beforeFind',
+      () => {
+        throw 'before find should have resolved using masterKey.';
+      },
+      {
+        skipWithMasterKey: true,
+      }
+    );
+    const obj = new Parse.Object('beforeFind');
+    obj.set('foo', 'bar');
+    await obj.save();
+    expect(obj.get('foo')).toBe('bar');
+    await obj.destroy({ useMasterKey: true });
+    done();
+  });
+
+  it('basic beforeSaveFile skipWithMasterKey', async done => {
+    Parse.Cloud.beforeSaveFile(
+      () => {
+        throw 'beforeSaveFile should have resolved using master key.';
+      },
+      {
+        skipWithMasterKey: true,
+      }
+    );
+    const file = new Parse.File('popeye.txt', [1, 2, 3], 'text/plain');
+    const result = await file.save({ useMasterKey: true });
+    expect(result).toBe(file);
+    done();
+  });
+
+  it('beforeSave validateMasterKey and skipWithMasterKey fail', async function (done) {
+    Parse.Cloud.beforeSave(
+      'BeforeSave',
+      () => {
+        throw 'beforeSaveFile should have resolved using master key.';
+      },
+      {
+        fields: ['foo'],
+        validateMasterKey: true,
+        skipWithMasterKey: true,
+      }
+    );
+
+    const obj = new Parse.Object('BeforeSave');
+    try {
+      await obj.save(null, { useMasterKey: true });
+      fail('function should have failed.');
+    } catch (error) {
+      expect(error.code).toEqual(Parse.Error.VALIDATION_ERROR);
+      expect(error.message).toEqual('Validation failed. Please specify data for foo.');
+      done();
+    }
+  });
+
+  it('beforeSave validateMasterKey and skipWithMasterKey success', async function (done) {
+    Parse.Cloud.beforeSave(
+      'BeforeSave',
+      () => {
+        throw 'beforeSaveFile should have resolved using master key.';
+      },
+      {
+        fields: ['foo'],
+        validateMasterKey: true,
+        skipWithMasterKey: true,
+      }
+    );
+
+    const obj = new Parse.Object('BeforeSave');
+    obj.set('foo', 'bar');
+    try {
+      await obj.save(null, { useMasterKey: true });
+      done();
+    } catch (error) {
+      fail('error should not have been called.');
+    }
+  });
+
   it('basic beforeSave requireUserKey on User Class', async function (done) {
     Parse.Cloud.beforeSave(Parse.User, () => {}, {
       requireUser: true,