How to use

serverURL

function

in

parse

it('limit query', done => {
  const options = Object.assign({}, masterKeyOptions, {
   body: {
    limit: 2,
   },
  });
  get(Parse.serverURL + '/aggregate/TestObject', options)
   .then(resp => {
    expect(resp.results.length).toBe(2);
    done();
   })
   .catch(done.fail);
 });

it('exclude keys with select same key', async () => {
  const obj = new TestObject({ foo: 'baz', hello: 'world' });
  await obj.save();

  const response = await request({
   url: Parse.serverURL + '/classes/TestObject',
   qs: {
    keys: 'foo',
    excludeKeys: 'foo',
    where: JSON.stringify({ objectId: obj.id }),
   },
   headers: masterKeyHeaders,
  });
  expect(response.data.results[0].foo).toBeUndefined();
  expect(response.data.results[0].hello).toBeUndefined();
 });

it('invalid query invalid key', done => {
  const options = Object.assign({}, masterKeyOptions, {
   body: {
    unknown: {},
   },
  });
  get(Parse.serverURL + '/aggregate/TestObject', options).catch(error => {
   expect(error.error.code).toEqual(Parse.Error.INVALID_QUERY);
   done();
  });
 });

it('distinct array', done => {
  const options = Object.assign({}, masterKeyOptions, {
   body: { distinct: 'size' },
  });
  get(Parse.serverURL + '/aggregate/TestObject', options)
   .then(resp => {
    expect(resp.results.length).toBe(3);
    expect(resp.results.includes('S')).toBe(true);
    expect(resp.results.includes('M')).toBe(true);
    expect(resp.results.includes('L')).toBe(true);
    done();
   })
   .catch(done.fail);
 });

it('match complex comparison query', done => {
  const options = Object.assign({}, masterKeyOptions, {
   body: {
    match: { score: { $gt: 5, $lt: 15 }, views: { $gt: 850, $lt: 1000 } },
   },
  });
  get(Parse.serverURL + '/aggregate/TestObject', options)
   .then(resp => {
    expect(resp.results.length).toBe(1);
    expect(resp.results[0].score).toBe(10);
    expect(resp.results[0].views).toBe(900);
    done();
   })
   .catch(done.fail);
 });

it('match comparison query', done => {
  const options = Object.assign({}, masterKeyOptions, {
   body: {
    match: { score: { $gt: 15 } },
   },
  });
  get(Parse.serverURL + '/aggregate/TestObject', options)
   .then(resp => {
    expect(resp.results.length).toBe(1);
    expect(resp.results[0].score).toBe(20);
    done();
   })
   .catch(done.fail);
 });

it('distinct query', done => {
  const options = Object.assign({}, masterKeyOptions, {
   body: { distinct: 'score' },
  });
  get(Parse.serverURL + '/aggregate/TestObject', options)
   .then(resp => {
    expect(resp.results.length).toBe(2);
    expect(resp.results.includes(10)).toBe(true);
    expect(resp.results.includes(20)).toBe(true);
    done();
   })
   .catch(done.fail);
 });

it('invalid query group _id', done => {
  const options = Object.assign({}, masterKeyOptions, {
   body: {
    group: { _id: null },
   },
  });
  get(Parse.serverURL + '/aggregate/TestObject', options).catch(error => {
   expect(error.error.code).toEqual(Parse.Error.INVALID_QUERY);
   done();
  });
 });

it('invalid query group objectId required', done => {
  const options = Object.assign({}, masterKeyOptions, {
   body: {
    group: {},
   },
  });
  get(Parse.serverURL + '/aggregate/TestObject', options).catch(error => {
   expect(error.error.code).toEqual(Parse.Error.INVALID_QUERY);
   done();
  });
 });

it('class does not exist return empty', done => {
  const options = Object.assign({}, masterKeyOptions, {
   body: {
    group: { objectId: null, total: { $sum: '$score' } },
   },
  });
  get(Parse.serverURL + '/aggregate/UnknownClass', options)
   .then(resp => {
    expect(resp.results.length).toBe(0);
    done();
   })
   .catch(done.fail);
 });

it('field does not exist return empty', done => {
  const options = Object.assign({}, masterKeyOptions, {
   body: {
    group: { objectId: null, total: { $sum: '$unknownfield' } },
   },
  });
  get(Parse.serverURL + '/aggregate/UnknownClass', options)
   .then(resp => {
    expect(resp.results.length).toBe(0);
    done();
   })
   .catch(done.fail);
 });

it('distinct class does not exist return empty', done => {
  const options = Object.assign({}, masterKeyOptions, {
   body: { distinct: 'unknown' },
  });
  get(Parse.serverURL + '/aggregate/UnknownClass', options)
   .then(resp => {
    expect(resp.results.length).toBe(0);
    done();
   })
   .catch(done.fail);
 });

it('distinct nested', done => {
  const options = Object.assign({}, masterKeyOptions, {
   body: { distinct: 'sender.group' },
  });
  get(Parse.serverURL + '/aggregate/TestObject', options)
   .then(resp => {
    expect(resp.results.length).toBe(2);
    expect(resp.results.includes('A')).toBe(true);
    expect(resp.results.includes('B')).toBe(true);
    done();
   })
   .catch(done.fail);
 });

it('skip query', done => {
  const options = Object.assign({}, masterKeyOptions, {
   body: {
    skip: 2,
   },
  });
  get(Parse.serverURL + '/aggregate/TestObject', options)
   .then(resp => {
    expect(resp.results.length).toBe(2);
    done();
   })
   .catch(done.fail);
 });

it('match comparison and equality query', done => {
  const options = Object.assign({}, masterKeyOptions, {
   body: {
    match: { score: { $gt: 5, $lt: 15 }, views: 900 },
   },
  });
  get(Parse.serverURL + '/aggregate/TestObject', options)
   .then(resp => {
    expect(resp.results.length).toBe(1);
    expect(resp.results[0].score).toBe(10);
    expect(resp.results[0].views).toBe(900);
    done();
   })
   .catch(done.fail);
 });