How to use

ACL

function

in

parse

beforeEach(async done => {
    const userACL = new Parse.ACL();
    userACL.setPublicReadAccess(true);
    await user.setACL(userACL).save(null, { useMasterKey: true });
    done();
   });

it('can match ACL with none exist requestId', function (done) {
  const parseLiveQueryServer = new ParseLiveQueryServer({});
  const acl = new Parse.ACL();
  const client = {
   getSubscriptionInfo: jasmine
    .createSpy('getSubscriptionInfo')
    .and.returnValue(undefined),
  };
  const requestId = 0;

  parseLiveQueryServer
   ._matchesACL(acl, client, requestId)
   .then(function (isMatched) {
    expect(isMatched).toBe(false);
    done();
   });
 });

it('test beforeDelete with locked down ACL', async () => {
  let called = false;
  Parse.Cloud.beforeDelete('GameScore', () => {
   called = true;
  });
  const object = new Parse.Object('GameScore');
  object.setACL(new Parse.ACL());
  await object.save();
  const objects = await new Parse.Query('GameScore').find();
  expect(objects.length).toBe(0);
  try {
   await object.destroy();
  } catch (e) {
   expect(e.code).toBe(Parse.Error.OBJECT_NOT_FOUND);
  }
  expect(called).toBe(false);
 });

it("won't match non-public ACL with role when there is no user", function (done) {
  const parseLiveQueryServer = new ParseLiveQueryServer({});
  const acl = new Parse.ACL();
  acl.setPublicReadAccess(false);
  acl.setRoleReadAccess('livequery', true);
  const client = {
   getSubscriptionInfo: jasmine
    .createSpy('getSubscriptionInfo')
    .and.returnValue({}),
  };
  const requestId = 0;

  parseLiveQueryServer
   ._matchesACL(acl, client, requestId)
   .then(function (isMatched) {
    expect(isMatched).toBe(false);
    done();
   })
   .catch(done.fail);
 });

it('test beforeSave set object acl success', function(done) {
  const acl = new Parse.ACL({
   '*': { read: true, write: false },
  });

it('can match ACL with valid client sessionToken', function (done) {
  const parseLiveQueryServer = new ParseLiveQueryServer({});
  const acl = new Parse.ACL();
  acl.setReadAccess(testUserId, true);
  // Mock sessionTokenCache will return false when sessionToken is undefined
  const client = {
   sessionToken: 'sessionToken',
   getSubscriptionInfo: jasmine
    .createSpy('getSubscriptionInfo')
    .and.returnValue({
     sessionToken: undefined,
    }),
  };
  const requestId = 0;

  parseLiveQueryServer
   ._matchesACL(acl, client, requestId)
   .then(function (isMatched) {
    expect(isMatched).toBe(true);
    done();
   });
 });

it("won't match ACL that doesn't have public read or any roles", function (done) {
  const parseLiveQueryServer = new ParseLiveQueryServer({});
  const acl = new Parse.ACL();
  acl.setPublicReadAccess(false);
  const client = {
   getSubscriptionInfo: jasmine
    .createSpy('getSubscriptionInfo')
    .and.returnValue({
     sessionToken: 'sessionToken',
    }),
  };
  const requestId = 0;

  parseLiveQueryServer
   ._matchesACL(acl, client, requestId)
   .then(function (isMatched) {
    expect(isMatched).toBe(false);
    done();
   });
 });

beforeEach(async done => {
    const userACL = new Parse.ACL();
    userACL.setPublicReadAccess(true);
    await user.setACL(userACL).save(null, { useMasterKey: true });
    done();
   });

it('will match non-public ACL when client has master key', function (done) {
  const parseLiveQueryServer = new ParseLiveQueryServer({});
  const acl = new Parse.ACL();
  acl.setPublicReadAccess(false);
  const client = {
   getSubscriptionInfo: jasmine
    .createSpy('getSubscriptionInfo')
    .and.returnValue({}),
   hasMasterKey: true,
  };
  const requestId = 0;

  parseLiveQueryServer
   ._matchesACL(acl, client, requestId)
   .then(function (isMatched) {
    expect(isMatched).toBe(true);
    done();
   });
 });

it('can match ACL with public read access', function (done) {
  const parseLiveQueryServer = new ParseLiveQueryServer({});
  const acl = new Parse.ACL();
  acl.setPublicReadAccess(true);
  const client = {
   getSubscriptionInfo: jasmine
    .createSpy('getSubscriptionInfo')
    .and.returnValue({
     sessionToken: 'sessionToken',
    }),
  };
  const requestId = 0;

  parseLiveQueryServer
   ._matchesACL(acl, client, requestId)
   .then(function (isMatched) {
    expect(isMatched).toBe(true);
    done();
   });
 });

it("won't match non-public ACL when client has no master key", function (done) {
  const parseLiveQueryServer = new ParseLiveQueryServer({});
  const acl = new Parse.ACL();
  acl.setPublicReadAccess(false);
  const client = {
   getSubscriptionInfo: jasmine
    .createSpy('getSubscriptionInfo')
    .and.returnValue({}),
   hasMasterKey: false,
  };
  const requestId = 0;

  parseLiveQueryServer
   ._matchesACL(acl, client, requestId)
   .then(function (isMatched) {
    expect(isMatched).toBe(false);
    done();
   });
 });

it('can match ACL with subscription sessionToken checking error', function (done) {
  const parseLiveQueryServer = new ParseLiveQueryServer({});
  const acl = new Parse.ACL();
  acl.setReadAccess(testUserId, true);
  // Mock sessionTokenCache will return error when sessionToken is null, this is just
  // the behaviour of our mock sessionTokenCache, not real sessionTokenCache
  const client = {
   getSubscriptionInfo: jasmine
    .createSpy('getSubscriptionInfo')
    .and.returnValue({
     sessionToken: null,
    }),
  };
  const requestId = 0;

  parseLiveQueryServer
   ._matchesACL(acl, client, requestId)
   .then(function (isMatched) {
    expect(isMatched).toBe(false);
    done();
   });
 });

it('can match ACL with valid subscription sessionToken', function (done) {
  const parseLiveQueryServer = new ParseLiveQueryServer({});
  const acl = new Parse.ACL();
  acl.setReadAccess(testUserId, true);
  const client = {
   getSubscriptionInfo: jasmine
    .createSpy('getSubscriptionInfo')
    .and.returnValue({
     sessionToken: 'sessionToken',
    }),
  };
  const requestId = 0;

  parseLiveQueryServer
   ._matchesACL(acl, client, requestId)
   .then(function (isMatched) {
    expect(isMatched).toBe(true);
    done();
   });
 });

it('can match ACL with invalid subscription and client sessionToken', function (done) {
  const parseLiveQueryServer = new ParseLiveQueryServer({});
  const acl = new Parse.ACL();
  acl.setReadAccess(testUserId, true);
  // Mock sessionTokenCache will return false when sessionToken is undefined
  const client = {
   sessionToken: undefined,
   getSubscriptionInfo: jasmine
    .createSpy('getSubscriptionInfo')
    .and.returnValue({
     sessionToken: undefined,
    }),
  };
  const requestId = 0;

  parseLiveQueryServer
   ._matchesACL(acl, client, requestId)
   .then(function (isMatched) {
    expect(isMatched).toBe(false);
    done();
   });
 });

it('can match ACL with client sessionToken checking error', function (done) {
  const parseLiveQueryServer = new ParseLiveQueryServer({});
  const acl = new Parse.ACL();
  acl.setReadAccess(testUserId, true);
  // Mock sessionTokenCache will return error when sessionToken is null
  const client = {
   sessionToken: null,
   getSubscriptionInfo: jasmine
    .createSpy('getSubscriptionInfo')
    .and.returnValue({
     sessionToken: null,
    }),
  };
  const requestId = 0;

  parseLiveQueryServer
   ._matchesACL(acl, client, requestId)
   .then(function (isMatched) {
    expect(isMatched).toBe(false);
    done();
   });
 });