ParseQuery-test.js

jest.dontMock('../CoreManager');
jest.dontMock('../encode');
jest.dontMock('../decode');
jest.dontMock('../ParseError');
jest.dontMock('../ParseGeoPoint');
jest.dontMock('../ParseQuery');
jest.dontMock('../promiseUtils');
jest.dontMock('../SingleInstanceStateController');
jest.dontMock('../UniqueInstanceStateController');
jest.dontMock('../ObjectStateMutations');
jest.dontMock('../LocalDatastore');
jest.dontMock('../OfflineQuery');
jest.dontMock('../LiveQuerySubscription');
jest.dontMock('../proxy');
jest.dontMock('deepcopy');

jest.mock('../uuid', () => {
  let value = 0;
  return () => value++;
});
const mockObject = function (className) {
  this.className = className;
  this.attributes = {};
};
mockObject.registerSubclass = function () {};
mockObject.fromJSON = function (json) {
  const o = new mockObject(json.className);
  o.id = json.objectId;
  for (const attr in json) {
    if (attr !== 'className' && attr !== '__type' && attr !== 'objectId') {
      o.attributes[attr] = json[attr];
    }
  }
  return o;
};
jest.setMock('../ParseObject', mockObject);

const mockLocalDatastore = {
  _serializeObjectsFromPinName: jest.fn(),
  checkIfEnabled: jest.fn(),
};
jest.setMock('../LocalDatastore', mockLocalDatastore);

let CoreManager = require('../CoreManager');
const ParseError = require('../ParseError').default;
const ParseGeoPoint = require('../ParseGeoPoint').default;
let ParseObject = require('../ParseObject');
let ParseQuery = require('../ParseQuery').default;
const LiveQuerySubscription = require('../LiveQuerySubscription').default;

const MockRESTController = {
  request: jest.fn(),
  ajax: jest.fn(),
};

const QueryController = CoreManager.getQueryController();

import { DEFAULT_PIN } from '../LocalDatastoreUtils';

describe('ParseQuery', () => {
  beforeEach(() => {
    CoreManager.setQueryController(QueryController);
    CoreManager.setRESTController(MockRESTController);
  });

  it('can be constructed from a class name', () => {
    const q = new ParseQuery('Item');
    expect(q.className).toBe('Item');
    expect(q.toJSON()).toEqual({
      where: {},
    });
  });

  it('can be constructed from a ParseObject', () => {
    const item = new ParseObject('Item');
    const q2 = new ParseQuery(item);
    expect(q2.className).toBe('Item');
    expect(q2.toJSON()).toEqual({
      where: {},
    });
  });

  it('can be constructed from a function constructor', () => {
    function ObjectFunction() {
      this.className = 'Item';
    }
    const q = new ParseQuery(ObjectFunction);
    expect(q.className).toBe('Item');
    expect(q.toJSON()).toEqual({
      where: {},
    });
  });

  it('can be constructed from a function prototype', () => {
    function ObjectFunction() {}
    ObjectFunction.className = 'Item';
    const q = new ParseQuery(ObjectFunction);
    expect(q.className).toBe('Item');
    expect(q.toJSON()).toEqual({
      where: {},
    });
  });

  it('throws when created with invalid data', () => {
    expect(function () {
      new ParseQuery();
    }).toThrow('A ParseQuery must be constructed with a ParseObject or class name.');
  });

  it('can generate equality queries', () => {
    const q = new ParseQuery('Item');
    q.equalTo('size', 'medium');
    expect(q.toJSON()).toEqual({
      where: {
        size: 'medium',
      },
    });

    // Overrides old constraint
    q.equalTo('size', 'small');
    expect(q.toJSON()).toEqual({
      where: {
        size: 'small',
      },
    });

    // equalTo('key', undefined) resolves to 'does not exist'
    q.equalTo('size');
    expect(q.toJSON()).toEqual({
      where: {
        size: {
          $exists: false,
        },
      },
    });

    const size = 'medium';
    const stock = true;
    q.equalTo({ size, stock });
    expect(q.toJSON()).toEqual({
      where: {
        size: 'medium',
        stock: true,
      },
    });
  });

  it('can generate inequality queries', () => {
    const q = new ParseQuery('Item');
    q.notEqualTo('size', 'small');
    expect(q.toJSON()).toEqual({
      where: {
        size: {
          $ne: 'small',
        },
      },
    });

    q.notEqualTo('size', 'medium');
    expect(q.toJSON()).toEqual({
      where: {
        size: {
          $ne: 'medium',
        },
      },
    });

    const size = 'medium';
    const stock = true;
    q.notEqualTo({ size, stock });
    expect(q.toJSON()).toEqual({
      where: {
        size: {
          $ne: 'medium',
        },
        stock: {
          $ne: true,
        },
      },
    });
  });

  it('can generate less-than queries', () => {
    const q = new ParseQuery('Item');
    q.lessThan('inStock', 10);
    expect(q.toJSON()).toEqual({
      where: {
        inStock: {
          $lt: 10,
        },
      },
    });

    q.lessThan('inStock', 4);
    expect(q.toJSON()).toEqual({
      where: {
        inStock: {
          $lt: 4,
        },
      },
    });
  });

  it('can generate less-than-or-equal-to queries', () => {
    const q = new ParseQuery('Item');
    q.lessThanOrEqualTo('inStock', 10);
    expect(q.toJSON()).toEqual({
      where: {
        inStock: {
          $lte: 10,
        },
      },
    });

    q.lessThanOrEqualTo('inStock', 4);
    expect(q.toJSON()).toEqual({
      where: {
        inStock: {
          $lte: 4,
        },
      },
    });
  });

  it('can generate greater-than queries', () => {
    const q = new ParseQuery('Item');
    q.greaterThan('inStock', 0);
    expect(q.toJSON()).toEqual({
      where: {
        inStock: {
          $gt: 0,
        },
      },
    });

    q.greaterThan('inStock', 100);
    expect(q.toJSON()).toEqual({
      where: {
        inStock: {
          $gt: 100,
        },
      },
    });
  });

  it('can generate greater-than-or-equal-to queries', () => {
    const q = new ParseQuery('Item');
    q.greaterThanOrEqualTo('inStock', 0);
    expect(q.toJSON()).toEqual({
      where: {
        inStock: {
          $gte: 0,
        },
      },
    });

    q.greaterThanOrEqualTo('inStock', 100);
    expect(q.toJSON()).toEqual({
      where: {
        inStock: {
          $gte: 100,
        },
      },
    });
  });

  it('can generate contained-in queries', () => {
    const q = new ParseQuery('Item');
    q.containedIn('size', ['small', 'medium']);
    expect(q.toJSON()).toEqual({
      where: {
        size: {
          $in: ['small', 'medium'],
        },
      },
    });

    q.containedIn('size', ['small', 'medium', 'large']);
    expect(q.toJSON()).toEqual({
      where: {
        size: {
          $in: ['small', 'medium', 'large'],
        },
      },
    });
  });

  it('can generate not-contained-in queries', () => {
    const q = new ParseQuery('Item');
    q.notContainedIn('size', ['small', 'medium']);
    expect(q.toJSON()).toEqual({
      where: {
        size: {
          $nin: ['small', 'medium'],
        },
      },
    });

    q.notContainedIn('size', ['small', 'large']);
    expect(q.toJSON()).toEqual({
      where: {
        size: {
          $nin: ['small', 'large'],
        },
      },
    });
  });

  it('can generate contains-all queries', () => {
    const q = new ParseQuery('Item');
    q.containsAll('tags', ['hot', 'sold-out']);
    expect(q.toJSON()).toEqual({
      where: {
        tags: {
          $all: ['hot', 'sold-out'],
        },
      },
    });

    q.containsAll('tags', ['sale', 'new']);
    expect(q.toJSON()).toEqual({
      where: {
        tags: {
          $all: ['sale', 'new'],
        },
      },
    });
  });

  it('can generate containedBy queries', () => {
    const q = new ParseQuery('Item');
    q.containedBy('tags', ['hot', 'sold-out']);
    expect(q.toJSON()).toEqual({
      where: {
        tags: {
          $containedBy: ['hot', 'sold-out'],
        },
      },
    });

    q.containedBy('tags', ['sale', 'new']);
    expect(q.toJSON()).toEqual({
      where: {
        tags: {
          $containedBy: ['sale', 'new'],
        },
      },
    });
  });

  it('can generate contains-all-starting-with queries', () => {
    const q = new ParseQuery('Item');
    q.containsAllStartingWith('tags', ['ho', 'out']);
    expect(q.toJSON()).toEqual({
      where: {
        tags: {
          $all: [{ $regex: '^\\Qho\\E' }, { $regex: '^\\Qout\\E' }],
        },
      },
    });

    q.containsAllStartingWith('tags', ['sal', 'ne']);
    expect(q.toJSON()).toEqual({
      where: {
        tags: {
          $all: [{ $regex: '^\\Qsal\\E' }, { $regex: '^\\Qne\\E' }],
        },
      },
    });

    q.containsAllStartingWith('tags', 'noArray');
    expect(q.toJSON()).toEqual({
      where: {
        tags: {
          $all: [{ $regex: '^\\QnoArray\\E' }],
        },
      },
    });
  });

  it('can generate exists queries', () => {
    const q = new ParseQuery('Item');
    q.exists('name');
    expect(q.toJSON()).toEqual({
      where: {
        name: {
          $exists: true,
        },
      },
    });
  });

  it('can generate does-not-exist queries', () => {
    const q = new ParseQuery('Item');
    q.doesNotExist('name');
    expect(q.toJSON()).toEqual({
      where: {
        name: {
          $exists: false,
        },
      },
    });
  });

  it('can generate RegExp queries', () => {
    const q = new ParseQuery('Item');
    q.matches('name', /ing$/);
    expect(q.toJSON()).toEqual({
      where: {
        name: {
          $regex: 'ing$',
        },
      },
    });

    q.matches('name', /\bor\b/, 'i');
    expect(q.toJSON()).toEqual({
      where: {
        name: {
          $regex: '\\bor\\b',
          $options: 'i',
        },
      },
    });

    q.matches('name', /\bor\b/i);
    expect(q.toJSON()).toEqual({
      where: {
        name: {
          $regex: '\\bor\\b',
          $options: 'i',
        },
      },
    });

    q.matches('name', /\bor\b/im);
    expect(q.toJSON()).toEqual({
      where: {
        name: {
          $regex: '\\bor\\b',
          $options: 'im',
        },
      },
    });
  });

  it('can generate queries that match results from other queries', () => {
    const q1 = new ParseQuery('Item');
    q1.equalTo('inStock', 0);

    const q2 = new ParseQuery('Purchase');
    q2.matchesQuery('item', q1);
    expect(q2.toJSON()).toEqual({
      where: {
        item: {
          $inQuery: {
            className: 'Item',
            where: {
              inStock: 0,
            },
          },
        },
      },
    });
  });

  it("can generate queries that don't match results from other queries", () => {
    const q1 = new ParseQuery('Item');
    q1.equalTo('inStock', 0);

    const q2 = new ParseQuery('Purchase');
    q2.doesNotMatchQuery('item', q1);
    expect(q2.toJSON()).toEqual({
      where: {
        item: {
          $notInQuery: {
            className: 'Item',
            where: {
              inStock: 0,
            },
          },
        },
      },
    });
  });

  it('can generate queries that match keys from other queries', () => {
    const q1 = new ParseQuery('Item');
    q1.equalTo('inStock', 0);

    const q2 = new ParseQuery('Review');
    q2.matchesKeyInQuery('itemName', 'name', q1);
    expect(q2.toJSON()).toEqual({
      where: {
        itemName: {
          $select: {
            key: 'name',
            query: {
              className: 'Item',
              where: {
                inStock: 0,
              },
            },
          },
        },
      },
    });
  });

  it("can generate queries that don't match keys from other queries", () => {
    const q1 = new ParseQuery('Item');
    q1.equalTo('inStock', 0);

    const q2 = new ParseQuery('Review');
    q2.doesNotMatchKeyInQuery('itemName', 'name', q1);
    expect(q2.toJSON()).toEqual({
      where: {
        itemName: {
          $dontSelect: {
            key: 'name',
            query: {
              className: 'Item',
              where: {
                inStock: 0,
              },
            },
          },
        },
      },
    });
  });

  it('can generate string-contains queries', () => {
    const q = new ParseQuery('Item');
    expect(q.contains.bind(q, 'name', 12)).toThrow(
      'The value being searched for must be a string.'
    );

    q.contains('name', ' or ');
    expect(q.toJSON()).toEqual({
      where: {
        name: {
          $regex: '\\Q or \\E',
        },
      },
    });

    // Test escaping in quote()
    q.contains('name', 'slash-E \\E');
    expect(q.toJSON()).toEqual({
      where: {
        name: {
          $regex: '\\Qslash-E \\E\\\\E\\Q\\E',
        },
      },
    });

    q.contains('name', 'slash-Q \\Q');
    expect(q.toJSON()).toEqual({
      where: {
        name: {
          $regex: '\\Qslash-Q \\Q\\E',
        },
      },
    });
  });

  it('can generate string-starts-with queries', () => {
    const q = new ParseQuery('Item');
    expect(q.startsWith.bind(q, 'name', 12)).toThrow(
      'The value being searched for must be a string.'
    );

    q.startsWith('name', 'Abc');
    expect(q.toJSON()).toEqual({
      where: {
        name: {
          $regex: '^\\QAbc\\E',
        },
      },
    });

    q.startsWith('name', 'Def');
    expect(q.toJSON()).toEqual({
      where: {
        name: {
          $regex: '^\\QDef\\E',
        },
      },
    });
  });

  it('can generate string-ends-with queries', () => {
    const q = new ParseQuery('Item');
    expect(q.endsWith.bind(q, 'name', 12)).toThrow(
      'The value being searched for must be a string.'
    );

    q.endsWith('name', 'XYZ');
    expect(q.toJSON()).toEqual({
      where: {
        name: {
          $regex: '\\QXYZ\\E$',
        },
      },
    });

    q.endsWith('name', 'xyz');
    expect(q.toJSON()).toEqual({
      where: {
        name: {
          $regex: '\\Qxyz\\E$',
        },
      },
    });
  });

  it('can generate near-geopoint queries', () => {
    const q = new ParseQuery('Shipment');
    q.near('shippedTo', new ParseGeoPoint(10, 20));
    expect(q.toJSON()).toEqual({
      where: {
        shippedTo: {
          $nearSphere: {
            __type: 'GeoPoint',
            latitude: 10,
            longitude: 20,
          },
        },
      },
    });

    q.near('shippedTo', [30, 40]);
    expect(q.toJSON()).toEqual({
      where: {
        shippedTo: {
          $nearSphere: {
            __type: 'GeoPoint',
            latitude: 30,
            longitude: 40,
          },
        },
      },
    });

    // GeoPoint's internal fallback
    q.near('shippedTo', 'string');
    expect(q.toJSON()).toEqual({
      where: {
        shippedTo: {
          $nearSphere: {
            __type: 'GeoPoint',
            latitude: 0,
            longitude: 0,
          },
        },
      },
    });
  });

  it('can generate near-geopoint queries with ranges', () => {
    const q = new ParseQuery('Shipment');
    q.withinRadians('shippedTo', [20, 40], 2, true);
    expect(q.toJSON()).toEqual({
      where: {
        shippedTo: {
          $nearSphere: {
            __type: 'GeoPoint',
            latitude: 20,
            longitude: 40,
          },
          $maxDistance: 2,
        },
      },
    });

    q.withinMiles('shippedTo', [20, 30], 3958.8, true);
    expect(q.toJSON()).toEqual({
      where: {
        shippedTo: {
          $nearSphere: {
            __type: 'GeoPoint',
            latitude: 20,
            longitude: 30,
          },
          $maxDistance: 1,
        },
      },
    });

    q.withinKilometers('shippedTo', [30, 30], 6371.0, true);
    expect(q.toJSON()).toEqual({
      where: {
        shippedTo: {
          $nearSphere: {
            __type: 'GeoPoint',
            latitude: 30,
            longitude: 30,
          },
          $maxDistance: 1,
        },
      },
    });
  });

  it('can generate near-geopoint queries without sorting', () => {
    const q = new ParseQuery('Shipment');
    q.withinRadians('shippedTo', new ParseGeoPoint(20, 40), 2, false);
    expect(q.toJSON()).toEqual({
      where: {
        shippedTo: {
          $geoWithin: {
            $centerSphere: [
              [40, 20], // This takes [lng, lat] vs. ParseGeoPoint [lat, lng].
              2,
            ],
          },
        },
      },
    });

    q.withinMiles('shippedTo', new ParseGeoPoint(20, 30), 3958.8, false);
    expect(q.toJSON()).toEqual({
      where: {
        shippedTo: {
          $geoWithin: {
            $centerSphere: [
              [30, 20], // This takes [lng, lat] vs. ParseGeoPoint [lat, lng].
              1,
            ],
          },
        },
      },
    });

    q.withinKilometers('shippedTo', new ParseGeoPoint(30, 30), 6371.0, false);
    expect(q.toJSON()).toEqual({
      where: {
        shippedTo: {
          $geoWithin: {
            $centerSphere: [
              [30, 30], // This takes [lng, lat] vs. ParseGeoPoint [lat, lng].
              1,
            ],
          },
        },
      },
    });
  });

  it('can generate geobox queries', () => {
    const q = new ParseQuery('Shipment');
    q.withinGeoBox('shippedTo', [20, 20], [10, 30]);
    expect(q.toJSON()).toEqual({
      where: {
        shippedTo: {
          $within: {
            $box: [
              {
                __type: 'GeoPoint',
                latitude: 20,
                longitude: 20,
              },
              {
                __type: 'GeoPoint',
                latitude: 10,
                longitude: 30,
              },
            ],
          },
        },
      },
    });
  });

  it('can combine multiple clauses', () => {
    const q = new ParseQuery('Item');
    q.lessThan('inStock', 10);
    q.greaterThan('inStock', 0);
    expect(q.toJSON()).toEqual({
      where: {
        inStock: {
          $lt: 10,
          $gt: 0,
        },
      },
    });

    q.containedIn('size', ['small', 'medium']);
    expect(q.toJSON()).toEqual({
      where: {
        inStock: {
          $lt: 10,
          $gt: 0,
        },
        size: {
          $in: ['small', 'medium'],
        },
      },
    });
  });

  it('can specify ordering', () => {
    const q = new ParseQuery('Item');
    q.greaterThan('inStock', 0).ascending('createdAt');
    expect(q.toJSON()).toEqual({
      where: {
        inStock: {
          $gt: 0,
        },
      },
      order: 'createdAt',
    });

    // overrides
    q.ascending('name');
    expect(q.toJSON()).toEqual({
      where: {
        inStock: {
          $gt: 0,
        },
      },
      order: 'name',
    });

    q.ascending('name');
    expect(q.toJSON()).toEqual({
      where: {
        inStock: {
          $gt: 0,
        },
      },
      order: 'name',
    });

    // removes whitespace
    q.ascending('  createdAt');
    expect(q.toJSON()).toEqual({
      where: {
        inStock: {
          $gt: 0,
        },
      },
      order: 'createdAt',
    });

    // add additional ordering
    q.addAscending('name');
    expect(q.toJSON()).toEqual({
      where: {
        inStock: {
          $gt: 0,
        },
      },
      order: 'createdAt,name',
    });

    q.ascending(['a', 'b', 'c']);
    expect(q.toJSON()).toEqual({
      where: {
        inStock: {
          $gt: 0,
        },
      },
      order: 'a,b,c',
    });

    q.ascending('name', 'createdAt');
    expect(q.toJSON()).toEqual({
      where: {
        inStock: {
          $gt: 0,
        },
      },
      order: 'name,createdAt',
    });

    q.descending('createdAt');
    expect(q.toJSON()).toEqual({
      where: {
        inStock: {
          $gt: 0,
        },
      },
      order: '-createdAt',
    });

    q.addAscending('name');
    expect(q.toJSON()).toEqual({
      where: {
        inStock: {
          $gt: 0,
        },
      },
      order: '-createdAt,name',
    });

    q.addDescending('a', 'b', 'c');
    expect(q.toJSON()).toEqual({
      where: {
        inStock: {
          $gt: 0,
        },
      },
      order: '-createdAt,name,-a,-b,-c',
    });

    q.descending(['a', 'b']);
    expect(q.toJSON()).toEqual({
      where: {
        inStock: {
          $gt: 0,
        },
      },
      order: '-a,-b',
    });

    const q2 = new ParseQuery('Item');
    q2.addDescending();
    expect(q2.toJSON()).toEqual({
      where: {},
      order: '',
    });

    const q3 = new ParseQuery('Item');
    q3.addAscending();
    expect(q3.toJSON()).toEqual({
      where: {},
      order: '',
    });
  });

  it('can establish skip counts', () => {
    const q = new ParseQuery('Item');
    expect(q.skip.bind(q, 'string')).toThrow('You can only skip by a positive number');
    expect(q.skip.bind(q, -5)).toThrow('You can only skip by a positive number');

    q.skip(4);
    expect(q.toJSON()).toEqual({
      where: {},
      skip: 4,
    });
    q.equalTo('name', 'Product 5');
    expect(q.toJSON()).toEqual({
      where: {
        name: 'Product 5',
      },
      skip: 4,
    });
  });

  it('can establish result limits', () => {
    const q = new ParseQuery('Item');
    expect(q.limit.bind(q, 'string')).toThrow('You can only set the limit to a numeric value');

    q.limit(10);
    expect(q.toJSON()).toEqual({
      where: {},
      limit: 10,
    });
    q.limit(-1);
    expect(q.toJSON()).toEqual({
      where: {},
    });
  });

  it('can set withCount flag in find query', () => {
    const q = new ParseQuery('Item');
    expect(q.withCount.bind(q, 'string')).toThrow('You can only set withCount to a boolean value');

    q.withCount(true);
    expect(q.toJSON()).toEqual({
      where: {},
      count: 1,
    });
    q.withCount(false);
    expect(q.toJSON()).toEqual({
      where: {},
    });
  });

  it('can set hint value', () => {
    const q = new ParseQuery('Item');
    q.hint('_id_');
    expect(q.toJSON()).toEqual({
      where: {},
      hint: '_id_',
    });
  });

  it('can set explain value', () => {
    const q = new ParseQuery('Item');
    q.explain();
    const json = q.toJSON();
    expect(json).toEqual({
      where: {},
      explain: true,
    });
    const q2 = new ParseQuery('Item');
    q2.withJSON(json);
    expect(q2._explain).toBe(true);

    q.explain(false);
    expect(q.toJSON()).toEqual({
      where: {},
    });
    expect(q.explain.bind(q, 'not boolean')).toThrow('You can only set explain to a boolean value');
  });

  it('can generate queries that include full data for pointers', () => {
    const q = new ParseQuery('Item');
    q.greaterThan('inStock', 0);
    q.include('manufacturer');
    expect(q.toJSON()).toEqual({
      where: {
        inStock: {
          $gt: 0,
        },
      },
      include: 'manufacturer',
    });

    q.include('previousModel', 'nextModel');
    expect(q.toJSON()).toEqual({
      where: {
        inStock: {
          $gt: 0,
        },
      },
      include: 'manufacturer,previousModel,nextModel',
    });

    q.include(['lastPurchaser', 'lastPurchase']);
    expect(q.toJSON()).toEqual({
      where: {
        inStock: {
          $gt: 0,
        },
      },
      include: 'manufacturer,previousModel,nextModel,lastPurchaser,lastPurchase',
    });
  });

  it('can includeAll for pointers', () => {
    const q = new ParseQuery('Item');
    q.includeAll();
    const json = q.toJSON();
    expect(json).toEqual({
      where: {},
      include: '*',
    });
    const q2 = new ParseQuery('Item');
    q2.withJSON(json);
    expect(q2._include).toEqual(['*']);
  });

  it('can exclude keys', () => {
    const q = new ParseQuery('Item');
    q.exclude('foo');
    const json = q.toJSON();
    expect(json).toEqual({
      where: {},
      excludeKeys: 'foo',
    });
    const q2 = new ParseQuery('Item');
    q2.withJSON(json);
    expect(q2._exclude).toEqual(['foo']);
  });

  it('can exclude multiple keys', () => {
    const q = new ParseQuery('Item');
    q.exclude(['foo', 'bar']);
    const json = q.toJSON();
    expect(json).toEqual({
      where: {},
      excludeKeys: 'foo,bar',
    });
    const q2 = new ParseQuery('Item');
    q2.withJSON(json);
    expect(q2._exclude).toEqual(['foo', 'bar']);
  });

  it('can use extraOptions', () => {
    const q = new ParseQuery('Item');
    q._extraOptions.randomOption = 'test';
    const json = q.toJSON();
    expect(json).toEqual({
      where: {},
      randomOption: 'test',
    });
    const q2 = new ParseQuery('Item');
    q2.withJSON(json);
    expect(q2._extraOptions.randomOption).toBe('test');
  });

  it('can use hint', () => {
    const q = new ParseQuery('Item');
    q.hint('_id_');
    const json = q.toJSON();
    expect(json).toEqual({
      where: {},
      hint: '_id_',
    });
    const q2 = new ParseQuery('Item');
    q2.withJSON(json);
    expect(q2._hint).toBe('_id_');
  });

  it('can specify certain fields to send back', () => {
    const q = new ParseQuery('Item');
    q.select('size');
    expect(q.toJSON()).toEqual({
      where: {},
      keys: 'size',
    });

    q.select('inStock', 'lastPurchase');
    expect(q.toJSON()).toEqual({
      where: {},
      keys: 'size,inStock,lastPurchase',
    });

    q.select(['weight', 'color']);
    expect(q.toJSON()).toEqual({
      where: {},
      keys: 'size,inStock,lastPurchase,weight,color',
    });
  });

  it('can combine queries with an OR clause', () => {
    const q = new ParseQuery('Item');
    let q2 = new ParseQuery('Purchase');
    expect(ParseQuery.or.bind(null, q, q2)).toThrow('All queries must be for the same class.');

    q2 = new ParseQuery('Item');
    q.equalTo('size', 'medium');
    q2.equalTo('size', 'large');

    let mediumOrLarge = ParseQuery.or(q, q2);
    expect(mediumOrLarge.toJSON()).toEqual({
      where: {
        $or: [{ size: 'medium' }, { size: 'large' }],
      },
    });

    // It removes limits, skips, etc
    q.skip(10);
    mediumOrLarge = ParseQuery.or(q, q2);
    expect(mediumOrLarge.toJSON()).toEqual({
      where: {
        $or: [{ size: 'medium' }, { size: 'large' }],
      },
    });
  });

  it('can combine queries with an AND clause', () => {
    const q = new ParseQuery('Item');
    let q2 = new ParseQuery('Purchase');
    expect(ParseQuery.and.bind(null, q, q2)).toThrow('All queries must be for the same class.');

    q2 = new ParseQuery('Item');
    q.equalTo('size', 'medium');
    q2.equalTo('size', 'large');

    let mediumOrLarge = ParseQuery.and(q, q2);
    expect(mediumOrLarge.toJSON()).toEqual({
      where: {
        $and: [{ size: 'medium' }, { size: 'large' }],
      },
    });

    // It removes limits, skips, etc
    q.limit(10);
    mediumOrLarge = ParseQuery.and(q, q2);
    expect(mediumOrLarge.toJSON()).toEqual({
      where: {
        $and: [{ size: 'medium' }, { size: 'large' }],
      },
    });
  });

  it('can combine queries with a NOR clause', () => {
    const q = new ParseQuery('Item');
    let q2 = new ParseQuery('Purchase');
    expect(ParseQuery.nor.bind(null, q, q2)).toThrow('All queries must be for the same class.');

    q2 = new ParseQuery('Item');
    q.equalTo('size', 'medium');
    q2.equalTo('size', 'large');

    let mediumOrLarge = ParseQuery.nor(q, q2);
    expect(mediumOrLarge.toJSON()).toEqual({
      where: {
        $nor: [{ size: 'medium' }, { size: 'large' }],
      },
    });

    // It removes limits, skips, etc
    q.limit(10);
    mediumOrLarge = ParseQuery.nor(q, q2);
    expect(mediumOrLarge.toJSON()).toEqual({
      where: {
        $nor: [{ size: 'medium' }, { size: 'large' }],
      },
    });
  });

  it('can get the first object of a query', done => {
    CoreManager.setQueryController({
      aggregate() {},
      find(className, params, options) {
        expect(className).toBe('Item');
        expect(params).toEqual({
          limit: 1,
          where: {
            size: 'small',
          },
        });
        expect(options.requestTask).toBeDefined();
        return Promise.resolve({
          results: [{ objectId: 'I1', size: 'small', name: 'Product 3' }],
        });
      },
    });

    const q = new ParseQuery('Item');
    q.equalTo('size', 'small')
      .first()
      .then(obj => {
        expect(obj instanceof ParseObject).toBe(true);
        expect(obj.className).toBe('Item');
        expect(obj.id).toBe('I1');
        expect(obj.attributes).toEqual({
          size: 'small',
          name: 'Product 3',
        });
        done();
      });
  });

  it('can pass options to a first() query', done => {
    CoreManager.setQueryController({
      aggregate() {},
      find(className, params, options) {
        expect(className).toBe('Item');
        expect(params).toEqual({
          limit: 1,
          where: {
            size: 'small',
          },
        });
        expect(options.useMasterKey).toEqual(true);
        expect(options.sessionToken).toEqual('1234');
        return Promise.resolve({
          results: [],
        });
      },
    });

    const q = new ParseQuery('Item');
    q.equalTo('size', 'small')
      .first({
        useMasterKey: true,
        sessionToken: '1234',
      })
      .then(obj => {
        expect(obj).toBe(undefined);
        done();
      });
  });

  it('can handle explain query', done => {
    CoreManager.setQueryController({
      aggregate() {},
      find(className, params, options) {
        expect(className).toBe('Item');
        expect(params).toEqual({
          explain: true,
          where: {
            size: 'small',
          },
        });
        expect(options.requestTask).toBeDefined();
        return Promise.resolve({
          results: {
            objectId: 'I1',
            size: 'small',
            name: 'Product 3',
          },
        });
      },
    });

    const q = new ParseQuery('Item');
    q.explain();
    q.equalTo('size', 'small')
      .find()
      .then(result => {
        expect(result.objectId).toBe('I1');
        expect(result.size).toBe('small');
        expect(result.name).toEqual('Product 3');
        done();
      });
  });

  it('can get a single object by id', done => {
    CoreManager.setQueryController({
      aggregate() {},
      find(className, params, options) {
        expect(className).toBe('Item');
        expect(params).toEqual({
          limit: 1,
          where: {
            objectId: 'I27',
          },
        });
        expect(options.requestTask).toBeDefined();
        return Promise.resolve({
          results: [{ objectId: 'I27', size: 'large', name: 'Product 27' }],
        });
      },
    });

    const q = new ParseQuery('Item');
    q.get('I27').then(obj => {
      expect(obj instanceof ParseObject).toBe(true);
      expect(obj.className).toBe('Item');
      expect(obj.id).toBe('I27');
      expect(obj.attributes).toEqual({
        size: 'large',
        name: 'Product 27',
      });
      done();
    });
  });

  it('can return raw json from query', async () => {
    CoreManager.setQueryController({
      aggregate() {},
      find() {
        return Promise.resolve({
          results: [
            {
              objectId: 'I1',
              size: 'small',
              name: 'Product 3',
            },
          ],
        });
      },
    });

    const q = new ParseQuery('Item');
    q.equalTo('size', 'small');
    const results = await q.find({ json: true });
    expect(results[0].objectId).toBe('I1');
    expect(results[0].size).toBe('small');
    expect(results[0].name).toEqual('Product 3');
    expect(results[0].className).toEqual('Item');

    let result = await q.first({ json: true });
    expect(result.objectId).toBe('I1');
    expect(result.size).toBe('small');
    expect(result.name).toEqual('Product 3');
    expect(result.className).toEqual('Item');

    result = await q.get(result.objectId, { json: true });
    expect(result.objectId).toBe('I1');
    expect(result.size).toBe('small');
    expect(result.name).toEqual('Product 3');
    expect(result.className).toEqual('Item');

    await q.each(
      obj => {
        expect(obj.objectId).toBe('I1');
        expect(obj.size).toBe('small');
        expect(obj.name).toEqual('Product 3');
        expect(obj.className).toEqual('Item');
      },
      { json: true }
    );
  });

  it('will error when getting a nonexistent object', done => {
    CoreManager.setQueryController({
      aggregate() {},
      find(className, params, options) {
        expect(className).toBe('Item');
        expect(params).toEqual({
          limit: 1,
          where: {
            objectId: 'I28',
          },
        });
        expect(options.requestTask).toBeDefined();
        return Promise.resolve({
          results: [],
        });
      },
    });

    const q = new ParseQuery('Item');
    q.get('I28').then(
      () => {
        // Should not be reached
        expect(true).toBe(false);
        done();
      },
      err => {
        expect(err.code).toBe(ParseError.OBJECT_NOT_FOUND);
        expect(err.message).toBe('Object not found.');
        done();
      }
    );
  });

  it('can pass options to a get() query', done => {
    const context = { a: 'a' };
    CoreManager.setQueryController({
      aggregate() {},
      find(className, params, options) {
        expect(className).toBe('Item');
        expect(params).toEqual({
          limit: 1,
          where: {
            objectId: 'I27',
          },
        });
        expect(options.useMasterKey).toEqual(true);
        expect(options.sessionToken).toEqual('1234');
        expect(options.context).toEqual(context);
        return Promise.resolve({
          results: [{ objectId: 'I27', size: 'large', name: 'Product 27' }],
        });
      },
    });

    const q = new ParseQuery('Item');
    q.get('I27', {
      useMasterKey: true,
      sessionToken: '1234',
      context: context,
    }).then(() => {
      done();
    });
  });

  it('can issue a count query', done => {
    CoreManager.setQueryController({
      aggregate() {},
      find(className, params, options) {
        expect(className).toBe('Item');
        expect(params).toEqual({
          limit: 0,
          count: 1,
          where: {
            size: 'small',
          },
        });
        expect(options.requestTask).toBeDefined();
        return Promise.resolve({
          results: [],
          count: 145,
        });
      },
    });

    const q = new ParseQuery('Item');
    q.equalTo('size', 'small')
      .count()
      .then(count => {
        expect(count).toBe(145);
        done();
      });
  });

  it('can pass options to a count query', done => {
    CoreManager.setQueryController({
      aggregate() {},
      find(className, params, options) {
        expect(className).toBe('Item');
        expect(params).toEqual({
          limit: 0,
          count: 1,
          where: {
            size: 'small',
          },
        });
        expect(options.useMasterKey).toEqual(true);
        expect(options.sessionToken).toEqual('1234');
        return Promise.resolve({
          results: [],
          count: 145,
        });
      },
    });

    const q = new ParseQuery('Item');
    q.equalTo('size', 'small')
      .count({
        useMasterKey: true,
        sessionToken: '1234',
      })
      .then(count => {
        expect(count).toBe(145);
        done();
      });
  });

  it('can issue a query to the controller', done => {
    CoreManager.setQueryController({
      aggregate() {},
      find(className, params, options) {
        expect(className).toBe('Item');
        expect(params).toEqual({
          limit: 2,
          skip: 8,
          keys: 'size,name',
          order: 'createdAt',
          where: {
            size: {
              $in: ['small', 'medium'],
            },
          },
          readPreference: 'PRIMARY',
          includeReadPreference: 'SECONDARY',
          subqueryReadPreference: 'SECONDARY_PREFERRED',
        });
        expect(options.requestTask).toBeDefined();
        return Promise.resolve({
          results: [
            { objectId: 'I55', size: 'medium', name: 'Product 55' },
            { objectId: 'I89', size: 'small', name: 'Product 89' },
          ],
        });
      },
    });

    const q = new ParseQuery('Item');
    q.containedIn('size', ['small', 'medium'])
      .limit(2)
      .skip(8)
      .ascending('createdAt')
      .select('size', 'name')
      .readPreference('PRIMARY', 'SECONDARY', 'SECONDARY_PREFERRED')
      .find()
      .then(objs => {
        expect(objs.length).toBe(2);
        expect(objs[0] instanceof ParseObject).toBe(true);
        expect(objs[0].attributes).toEqual({
          size: 'medium',
          name: 'Product 55',
        });
        expect(objs[1] instanceof ParseObject).toBe(true);
        expect(objs[1].attributes).toEqual({
          size: 'small',
          name: 'Product 89',
        });
        done();
      });
  });

  it('can pass options to find()', done => {
    const context = { a: 'a' };
    CoreManager.setQueryController({
      aggregate() {},
      find(className, params, options) {
        expect(className).toBe('Item');
        expect(params).toEqual({
          where: {
            size: {
              $in: ['small', 'medium'],
            },
          },
        });
        expect(options.useMasterKey).toEqual(true);
        expect(options.sessionToken).toEqual('1234');
        expect(options.context).toEqual(context);
        return Promise.resolve({
          results: [],
        });
      },
    });

    const q = new ParseQuery('Item');
    q.containedIn('size', ['small', 'medium'])
      .find({
        useMasterKey: true,
        sessionToken: '1234',
        context: context,
      })
      .then(objs => {
        expect(objs).toEqual([]);
        done();
      });
  });

  it('can receive both count and objects from find() using withCount flag', done => {
    CoreManager.setQueryController({
      aggregate() {},
      find(className, params, options) {
        expect(className).toBe('Item');
        expect(params).toEqual({
          where: {},
          count: 1,
        });
        expect(options.useMasterKey).toEqual(true);
        expect(options.sessionToken).toEqual('1234');
        return Promise.resolve({
          results: [
            { objectId: '1', name: 'Product 55' },
            { objectId: '2', name: 'Product 89' },
          ],
          count: 2,
        });
      },
    });

    const q = new ParseQuery('Item');
    q.withCount(true)
      .find({
        useMasterKey: true,
        sessionToken: '1234',
      })
      .then(obj => {
        expect(obj.results).toBeDefined();
        expect(obj.results.length).toBe(2);
        expect(obj.count).toBeDefined();
        expect(typeof obj.count).toBe('number');
        done();
      });
  });

  describe('iterating over batches with .eachBatch()', () => {
    let findMock;
    beforeEach(() => {
      findMock = jest.fn();
      findMock.mockReturnValueOnce(
        Promise.resolve({
          results: [
            { objectId: 'I55', size: 'medium', name: 'Product 55' },
            { objectId: 'I89', size: 'small', name: 'Product 89' },
          ],
        })
      );
      findMock.mockReturnValueOnce(
        Promise.resolve({
          results: [{ objectId: 'I91', size: 'small', name: 'Product 91' }],
        })
      );
      CoreManager.setQueryController({
        aggregate() {},
        find: findMock,
      });
    });

    it('passes query attributes through to the REST API', async () => {
      const q = new ParseQuery('Item');
      q.containedIn('size', ['small', 'medium']);
      q.matchesKeyInQuery('name', 'productName', new ParseQuery('Review').equalTo('stars', 5));
      q.equalTo('valid', true);
      q.equalTo('arrayField', ['a', 'b']);
      q.select('size', 'name');
      q.includeAll();
      q.hint('_id_');

      await q.eachBatch(() => {});

      expect(findMock).toHaveBeenCalledTimes(1);
      const [className, params, options] = findMock.mock.calls[0];
      expect(className).toBe('Item');
      expect(params).toEqual({
        limit: 100,
        order: 'objectId',
        keys: 'size,name',
        include: '*',
        hint: '_id_',
        where: {
          arrayField: ['a', 'b'],
          size: {
            $in: ['small', 'medium'],
          },
          name: {
            $select: {
              key: 'productName',
              query: {
                className: 'Review',
                where: {
                  stars: 5,
                },
              },
            },
          },
          valid: true,
        },
      });
      expect(options.requestTask).toBeDefined();
    });

    it('passes options through to the REST API', async () => {
      const batchOptions = {
        useMasterKey: true,
        sessionToken: '1234',
        batchSize: 50,
      };
      const q = new ParseQuery('Item');
      await q.eachBatch(() => {}, batchOptions);
      expect(findMock).toHaveBeenCalledTimes(1);
      const [className, params, options] = findMock.mock.calls[0];
      expect(className).toBe('Item');
      expect(params).toEqual({
        limit: 50,
        order: 'objectId',
        where: {},
      });
      expect(options.useMasterKey).toBe(true);
      expect(options.sessionToken).toEqual('1234');
    });

    it('only makes one request when the results fit in one page', async () => {
      const q = new ParseQuery('Item');
      await q.eachBatch(() => {});
      expect(findMock).toHaveBeenCalledTimes(1);
    });

    it('makes more requests when the results do not fit in one page', async () => {
      const q = new ParseQuery('Item');
      await q.eachBatch(() => {}, { batchSize: 2 });
      expect(findMock).toHaveBeenCalledTimes(2);
    });

    it('stops iteration when the callback returns a promise that rejects', async () => {
      let callCount = 0;
      const callback = () => {
        callCount++;
        return Promise.reject(new Error('Callback rejecting'));
      };
      const q = new ParseQuery('Item');
      await q.eachBatch(callback, { batchSize: 2 }).catch(() => {});
      expect(callCount).toBe(1);
    });

    it('handles a synchronous callback', async () => {
      const results = [];
      const q = new ParseQuery('Item');
      await q.eachBatch(items => {
        items.map(item => results.push(item.attributes.size));
      });
      expect(results).toEqual(['medium', 'small']);
    });

    it('handles an asynchronous callback', async () => {
      const results = [];
      const q = new ParseQuery('Item');
      await q.eachBatch(items => {
        items.map(item => results.push(item.attributes.size));
      });
      expect(results).toEqual(['medium', 'small']);
    });
  });

  describe('return all objects with .findAll()', () => {
    let findMock;
    beforeEach(() => {
      findMock = jest.fn();
      findMock.mockReturnValueOnce(
        Promise.resolve({
          results: [
            { objectId: 'I55', size: 'medium', name: 'Product 55' },
            { objectId: 'I89', size: 'small', name: 'Product 89' },
          ],
        })
      );
      findMock.mockReturnValueOnce(
        Promise.resolve({
          results: [{ objectId: 'I91', size: 'small', name: 'Product 91' }],
        })
      );
      CoreManager.setQueryController({
        aggregate() {},
        find: findMock,
      });
    });

    it('passes query attributes through to the REST API', async () => {
      const q = new ParseQuery('Item');
      q.containedIn('size', ['small', 'medium']);
      q.matchesKeyInQuery('name', 'productName', new ParseQuery('Review').equalTo('stars', 5));
      q.equalTo('valid', true);
      q.select('size', 'name');
      q.includeAll();
      q.hint('_id_');

      await q.findAll();
      expect(findMock).toHaveBeenCalledTimes(1);
      const [className, params, options] = findMock.mock.calls[0];
      expect(className).toBe('Item');
      expect(params).toEqual({
        limit: 100,
        order: 'objectId',
        keys: 'size,name',
        include: '*',
        hint: '_id_',
        where: {
          size: {
            $in: ['small', 'medium'],
          },
          name: {
            $select: {
              key: 'productName',
              query: {
                className: 'Review',
                where: {
                  stars: 5,
                },
              },
            },
          },
          valid: true,
        },
      });
      expect(options.requestTask).toBeDefined();
    });

    it('passes options through to the REST API', async () => {
      const batchOptions = {
        useMasterKey: true,
        sessionToken: '1234',
        batchSize: 50,
      };
      const q = new ParseQuery('Item');
      await q.findAll(batchOptions);
      expect(findMock).toHaveBeenCalledTimes(1);
      const [className, params, options] = findMock.mock.calls[0];
      expect(className).toBe('Item');
      expect(params).toEqual({
        limit: 50,
        order: 'objectId',
        where: {},
      });
      expect(options.useMasterKey).toBe(true);
      expect(options.sessionToken).toEqual('1234');
    });

    it('only makes one request when the results fit in one page', async () => {
      const q = new ParseQuery('Item');
      await q.findAll();
      expect(findMock).toHaveBeenCalledTimes(1);
    });

    it('makes more requests when the results do not fit in one page', async () => {
      const q = new ParseQuery('Item');
      await q.findAll({ batchSize: 2 });
      expect(findMock).toHaveBeenCalledTimes(2);
    });

    it('Returns all objects', async () => {
      const q = new ParseQuery('Item');
      const results = await q.findAll();
      expect(results.map(obj => obj.attributes.size)).toEqual(['medium', 'small']);
    });
  });

  it('can iterate over results with each()', done => {
    CoreManager.setQueryController({
      aggregate() {},
      find(className, params, options) {
        expect(className).toBe('Item');
        expect(params).toEqual({
          limit: 100,
          order: 'objectId',
          keys: 'size,name',
          include: '*',
          where: {
            size: {
              $in: ['small', 'medium'],
            },
            name: {
              $select: {
                key: 'productName',
                query: {
                  className: 'Review',
                  where: {
                    stars: 5,
                  },
                },
              },
            },
            valid: true,
          },
        });
        expect(options.requestTask).toBeDefined();
        return Promise.resolve({
          results: [
            { objectId: 'I55', size: 'medium', name: 'Product 55' },
            { objectId: 'I89', size: 'small', name: 'Product 89' },
            { objectId: 'I91', size: 'small', name: 'Product 91' },
          ],
        });
      },
    });

    const q = new ParseQuery('Item');
    q.containedIn('size', ['small', 'medium']);
    q.matchesKeyInQuery('name', 'productName', new ParseQuery('Review').equalTo('stars', 5));
    q.equalTo('valid', true);
    q.select('size', 'name');
    q.includeAll();
    let calls = 0;

    q.each(() => {
      calls++;
    }).then(() => {
      expect(calls).toBe(3);
      done();
    });
  });

  it('can pass options to each()', done => {
    const context = { a: 'a' };
    CoreManager.setQueryController({
      aggregate() {},
      find(className, params, options) {
        expect(className).toBe('Item');
        expect(params).toEqual({
          limit: 100,
          order: 'objectId',
          keys: 'size,name',
          where: {
            size: {
              $in: ['small', 'medium'],
            },
            valid: true,
          },
        });
        expect(options.useMasterKey).toEqual(true);
        expect(options.sessionToken).toEqual('1234');
        expect(options.context).toEqual(context);
        return Promise.resolve({
          results: [
            { objectId: 'I55', size: 'medium', name: 'Product 55' },
            { objectId: 'I89', size: 'small', name: 'Product 89' },
            { objectId: 'I91', size: 'small', name: 'Product 91' },
          ],
        });
      },
    });

    const q = new ParseQuery('Item');
    q.containedIn('size', ['small', 'medium']);
    q.equalTo('valid', true);
    q.select('size', 'name');
    let calls = 0;

    q.each(
      () => {
        calls++;
      },
      {
        useMasterKey: true,
        sessionToken: '1234',
        context: context,
      }
    ).then(() => {
      expect(calls).toBe(3);
      done();
    });
  });

  it('can pass options to each() with hint', done => {
    const context = { a: 'a' };
    CoreManager.setQueryController({
      aggregate() {},
      find(className, params, options) {
        expect(className).toBe('Item');
        expect(params).toEqual({
          limit: 100,
          order: 'objectId',
          keys: 'size,name',
          where: {
            size: {
              $in: ['small', 'medium'],
            },
            valid: true,
          },
          hint: '_id_',
        });
        expect(options.useMasterKey).toEqual(true);
        expect(options.sessionToken).toEqual('1234');
        expect(options.context).toEqual(context);
        return Promise.resolve({
          results: [
            { objectId: 'I55', size: 'medium', name: 'Product 55' },
            { objectId: 'I89', size: 'small', name: 'Product 89' },
            { objectId: 'I91', size: 'small', name: 'Product 91' },
          ],
        });
      },
    });

    const q = new ParseQuery('Item');
    q.containedIn('size', ['small', 'medium']);
    q.equalTo('valid', true);
    q.select('size', 'name');
    q.hint('_id_');
    let calls = 0;

    q.each(
      () => {
        calls++;
      },
      {
        useMasterKey: true,
        sessionToken: '1234',
        context: context,
      }
    ).then(() => {
      expect(calls).toBe(3);
      done();
    });
  });

  it('should add hint as string', () => {
    const q = new ParseQuery('Item');
    q.hint('_id_');
    expect(q._hint).toBe('_id_');
  });

  it('should set hint as object', () => {
    const q = new ParseQuery('Item');
    q.hint({ _id: 1 });
    expect(q._hint).toStrictEqual({ _id: 1 });
  });

  it('should delete hint when set as undefined', () => {
    const q = new ParseQuery('Item');
    q.hint('_id_');
    expect(q._hint).toBe('_id_');
    q.hint();
    expect(q._hint).toBeUndefined();
  });

  describe('iterating over results via .map()', () => {
    beforeEach(() => {
      CoreManager.setQueryController({
        aggregate() {},
        find() {
          return Promise.resolve({
            results: [
              { objectId: 'I55', size: 'medium', name: 'Product 55' },
              { objectId: 'I89', size: 'small', name: 'Product 89' },
              { objectId: 'I91', size: 'small', name: 'Product 91' },
            ],
          });
        },
      });
    });

    it('can iterate with a synchronous callback', async () => {
      const callback = object => object.attributes.size;
      const q = new ParseQuery('Item');
      const results = await q.map(callback);
      expect(results).toEqual(['medium', 'small', 'small']);
    });

    it('can iterate with an asynchronous callback', async () => {
      const callback = async object => object.attributes.size;
      const q = new ParseQuery('Item');
      const results = await q.map(callback);
      expect(results).toEqual(['medium', 'small', 'small']);
    });

    it('stops iteration when a rejected promise is returned', async () => {
      let callCount = 0;
      await new ParseQuery('Item')
        .map(() => {
          callCount++;
          return Promise.reject(new Error('Callback rejecting'));
        })
        .catch(() => {});
      expect(callCount).toEqual(1);
    });
  });

  describe('iterating over results with .reduce()', () => {
    beforeEach(() => {
      CoreManager.setQueryController({
        aggregate() {},
        find() {
          return Promise.resolve({
            results: [
              { objectId: 'I55', number: 1 },
              { objectId: 'I89', number: 2 },
              { objectId: 'I91', number: 3 },
            ],
          });
        },
      });
    });

    it('can iterate with a synchronous callback', async () => {
      const callback = (accumulator, object) => accumulator + object.attributes.number;
      const q = new ParseQuery('Item');
      const result = await q.reduce(callback, 0);
      expect(result).toBe(6);
    });

    it('can iterate with an asynchronous callback', async () => {
      const callback = async (accumulator, object) => accumulator + object.attributes.number;
      const q = new ParseQuery('Item');
      const result = await q.reduce(callback, 0);
      expect(result).toBe(6);
    });

    it('stops iteration when a rejected promise is returned', async () => {
      let callCount = 0;
      const callback = () => {
        callCount += 1;
        return Promise.reject(new Error('Callback rejecting'));
      };
      const q = new ParseQuery('Item');
      await q.reduce(callback, 0).catch(() => {});
      expect(callCount).toBe(1);
    });

    it('uses the first object as an initial value when no initial value is passed', async () => {
      let callCount = 0;
      const callback = (accumulator, object) => {
        callCount += 1;
        accumulator.attributes.number += object.attributes.number;
        return accumulator;
      };
      const q = new ParseQuery('Item');
      const result = await q.reduce(callback);
      expect(result.id).toBe('I55');
      expect(result.attributes.number).toBe(6);
      expect(callCount).toBe(2); // Not called for the first object when used as initial value
    });

    it('rejects with a TypeError when there are no results and no initial value was provided', async () => {
      CoreManager.setQueryController({
        aggregate() {},
        find() {
          return Promise.resolve({ results: [] });
        },
      });

      const q = new ParseQuery('Item');
      const callback = (accumulator, object) => {
        accumulator.attributes.number += object.attributes.number;
        return accumulator;
      };
      return expect(q.reduce(callback)).rejects.toThrow(TypeError);
    });
  });

  describe('iterating over results with .filter()', () => {
    beforeEach(() => {
      CoreManager.setQueryController({
        aggregate() {},
        find() {
          return Promise.resolve({
            results: [
              { objectId: 'I55', size: 'medium', name: 'Product 55' },
              { objectId: 'I89', size: 'small', name: 'Product 89' },
              { objectId: 'I91', size: 'small', name: 'Product 91' },
            ],
          });
        },
      });
    });

    it('can iterate results with a synchronous callback', async () => {
      const callback = object => object.attributes.size === 'small';
      const q = new ParseQuery('Item');
      const results = await q.filter(callback);
      expect(results.length).toBe(2);
    });

    it('can iterate results with an async callback', async () => {
      const callback = async object => object.attributes.size === 'small';
      const q = new ParseQuery('Item');
      const results = await q.filter(callback);
      expect(results.length).toBe(2);
    });

    it('stops iteration when a rejected promise is returned', async () => {
      let callCount = 0;
      const callback = async () => {
        callCount += 1;
        return Promise.reject(new Error('Callback rejecting'));
      };
      const q = new ParseQuery('Item');
      await q.filter(callback).catch(() => {});
      expect(callCount).toBe(1);
    });
  });

  it('returns an error when iterating over an invalid query', done => {
    const q = new ParseQuery('Item');
    q.limit(10);
    q.each(() => {}).then(
      () => {
        // this should not be reached
        expect(true).toBe(false);
        done();
      },
      err => {
        expect(err).toBe('Cannot iterate on a query with sort, skip, or limit.');
        done();
      }
    );
  });

  it('rewrites User queries when the rewrite is enabled', () => {
    CoreManager.set('PERFORM_USER_REWRITE', true);
    let q = new ParseQuery('User');
    expect(q.className).toBe('_User');
    CoreManager.set('PERFORM_USER_REWRITE', false);
    q = new ParseQuery('User');
    expect(q.className).toBe('User');
  });

  it('does not override the className if it comes from the server', done => {
    CoreManager.setQueryController({
      aggregate() {},
      find() {
        return Promise.resolve({
          results: [{ className: 'Product', objectId: 'P40', name: 'Product 40' }],
        });
      },
    });

    const q = new ParseQuery('Item');
    q.find().then(results => {
      expect(results[0].className).toBe('Product');
      done();
    });
  });

  it('can override the className with a name from the server', done => {
    CoreManager.setQueryController({
      aggregate() {},
      find() {
        return Promise.resolve({
          results: [{ objectId: 'P41', name: 'Product 41' }],
          className: 'Product',
        });
      },
    });

    const q = new ParseQuery('Item');
    q.find().then(results => {
      expect(results[0].className).toBe('Product');
      done();
    });
  });

  it('overrides cached object with query results', done => {
    jest.dontMock('../ParseObject');
    jest.resetModules();
    ParseObject = require('../ParseObject').default;
    CoreManager = require('../CoreManager');
    ParseQuery = require('../ParseQuery').default;

    ParseObject.enableSingleInstance();

    let objectToReturn = {
      objectId: 'T01',
      name: 'Name',
      other: 'other',
      className: 'Thing',
      createdAt: '2017-01-10T10:00:00Z',
    };

    CoreManager.setQueryController({
      aggregate() {},
      find() {
        return Promise.resolve({
          results: [objectToReturn],
        });
      },
    });

    const q = new ParseQuery('Thing');
    let testObject;
    q.find()
      .then(results => {
        testObject = results[0];

        expect(testObject.get('name')).toBe('Name');
        expect(testObject.get('other')).toBe('other');

        objectToReturn = { objectId: 'T01', name: 'Name2' };
        const q2 = new ParseQuery('Thing');
        return q2.find();
      })
      .then(results => {
        expect(results[0].get('name')).toBe('Name2');
        expect(results[0].has('other')).toBe(false);
      })
      .then(() => {
        expect(testObject.get('name')).toBe('Name2');
        expect(testObject.has('other')).toBe(false);
        done();
      });
  });

  it('does not override unselected fields with select query results', done => {
    jest.dontMock('../ParseObject');
    jest.resetModules();
    ParseObject = require('../ParseObject').default;
    CoreManager = require('../CoreManager');
    ParseQuery = require('../ParseQuery').default;

    ParseObject.enableSingleInstance();

    let objectToReturn = {
      objectId: 'T01',
      name: 'Name',
      other: 'other',
      tbd: 'exists',
      className: 'Thing',
      createdAt: '2017-01-10T10:00:00Z',
      subObject: { key1: 'value', key2: 'value2', key3: 'thisWillGoAway' },
    };

    CoreManager.setQueryController({
      aggregate() {},
      find() {
        return Promise.resolve({
          results: [objectToReturn],
        });
      },
    });

    const q = new ParseQuery('Thing');
    let testObject;
    q
      .find()
      .then(results => {
        testObject = results[0];

        expect(testObject.get('name')).toBe('Name');
        expect(testObject.get('other')).toBe('other');
        expect(testObject.has('tbd')).toBe(true);
        expect(testObject.get('subObject').key1).toBe('value');
        expect(testObject.get('subObject').key2).toBe('value2');
        expect(testObject.get('subObject').key3).toBe('thisWillGoAway');

        const q2 = new ParseQuery('Thing');
        q2.select('other', 'tbd', 'subObject.key1', 'subObject.key3');
        objectToReturn = {
          objectId: 'T01',
          other: 'other2',
          subObject: { key1: 'updatedValue' },
        };
        return q2.find();
      })
      .then(results => {
        expect(results[0].get('name')).toBe('Name'); //query didn't select this
        expect(results[0].get('other')).toBe('other2'); //query selected and updated this
        expect(results[0].has('tbd')).toBe(false); //query selected this and it wasn't returned
        //sub-objects should work similarly
        expect(results[0].get('subObject').key1).toBe('updatedValue');
        expect(results[0].get('subObject').key2).toBe('value2');
        expect(results[0].get('subObject').key3).toBeUndefined();
      })
      .then(
        () => {
          expect(testObject.get('name')).toBe('Name');
          expect(testObject.get('other')).toBe('other2');
          expect(testObject.has('tbd')).toBe(false);
          expect(testObject.get('subObject').key1).toBe('updatedValue');
          expect(testObject.get('subObject').key2).toBe('value2');
          expect(testObject.get('subObject').key3).toBeUndefined();
          done();
        },
        error => {
          done.fail(error);
        }
      );
  });

  it('overrides cached object with first() results', done => {
    jest.dontMock('../ParseObject');
    jest.resetModules();
    ParseObject = require('../ParseObject').default;
    CoreManager = require('../CoreManager');
    ParseQuery = require('../ParseQuery').default;

    ParseObject.enableSingleInstance();

    let objectToReturn = {
      objectId: 'T01',
      name: 'Name',
      other: 'other',
      className: 'Thing',
      createdAt: '2017-01-10T10:00:00Z',
    };

    CoreManager.setQueryController({
      aggregate() {},
      find() {
        return Promise.resolve({
          results: [objectToReturn],
        });
      },
    });

    const q = new ParseQuery('Thing');
    let testObject;
    q.first()
      .then(result => {
        testObject = result;

        expect(testObject.get('name')).toBe('Name');
        expect(testObject.get('other')).toBe('other');

        objectToReturn = { objectId: 'T01', name: 'Name2' };
        const q2 = new ParseQuery('Thing');
        return q2.first();
      })
      .then(result => {
        expect(result.get('name')).toBe('Name2');
        expect(result.has('other')).toBe(false);
      })
      .then(() => {
        expect(testObject.get('name')).toBe('Name2');
        expect(testObject.has('other')).toBe(false);
        done();
      });
  });

  it('does not override unselected fields for first() on select query', done => {
    jest.dontMock('../ParseObject');
    jest.resetModules();
    ParseObject = require('../ParseObject').default;
    CoreManager = require('../CoreManager');
    ParseQuery = require('../ParseQuery').default;

    ParseObject.enableSingleInstance();

    let objectToReturn = {
      objectId: 'T01',
      name: 'Name',
      other: 'other',
      tbd: 'exists',
      className: 'Thing',
      subObject: { key1: 'value', key2: 'value2', key3: 'thisWillGoAway' },
      createdAt: '2017-01-10T10:00:00Z',
    };

    CoreManager.setQueryController({
      aggregate() {},
      find() {
        return Promise.resolve({
          results: [objectToReturn],
        });
      },
    });

    const q = new ParseQuery('Thing');
    let testObject;
    q
      .first()
      .then(result => {
        testObject = result;

        expect(testObject.get('name')).toBe('Name');
        expect(testObject.get('other')).toBe('other');
        expect(testObject.has('tbd')).toBe(true);

        const q2 = new ParseQuery('Thing');
        q2.select('other', 'tbd', 'subObject.key1', 'subObject.key3');
        objectToReturn = {
          objectId: 'T01',
          other: 'other2',
          subObject: { key1: 'updatedValue' },
        };
        return q2.first();
      })
      .then(result => {
        expect(result.get('name')).toBe('Name'); //query didn't select this
        expect(result.get('other')).toBe('other2'); //query selected and updated this
        expect(result.has('tbd')).toBe(false); //query selected this and it wasn't returned
        //sub-objects should work similarly
        expect(result.get('subObject').key1).toBe('updatedValue');
        expect(result.get('subObject').key2).toBe('value2');
        expect(result.get('subObject').key3).toBeUndefined();
      })
      .then(
        () => {
          expect(testObject.get('name')).toBe('Name');
          expect(testObject.get('other')).toBe('other2');
          expect(testObject.has('tbd')).toBe(false);
          expect(testObject.get('subObject').key1).toBe('updatedValue');
          expect(testObject.get('subObject').key2).toBe('value2');
          expect(testObject.get('subObject').key3).toBeUndefined();
          done();
        },
        error => {
          done.fail(error);
        }
      );
  });

  it('restores queries from json representation', () => {
    const q = new ParseQuery('Item');

    q.include('manufacturer');
    q.select('inStock', 'lastPurchase');
    q.limit(10);
    q.withCount(true);
    q.ascending(['a', 'b', 'c']);
    q.skip(4);
    q.equalTo('size', 'medium');

    const json = q.toJSON();

    const newQuery = ParseQuery.fromJSON('Item', json);

    expect(newQuery.className).toBe('Item');

    expect(newQuery.toJSON()).toEqual({
      include: 'manufacturer',
      keys: 'inStock,lastPurchase',
      limit: 10,
      count: 1,
      order: 'a,b,c',
      skip: 4,
      where: {
        size: 'medium',
      },
    });
  });

  it('can issue a distinct query', done => {
    CoreManager.setQueryController({
      find() {},
      aggregate(className, params, options) {
        expect(className).toBe('Item');
        expect(params).toEqual({
          distinct: 'size',
          where: {
            size: 'small',
          },
        });
        expect(options.useMasterKey).toEqual(true);
        expect(options.requestTask).toBeDefined();
        return Promise.resolve({
          results: ['L'],
        });
      },
    });

    const q = new ParseQuery('Item');
    q.equalTo('size', 'small')
      .distinct('size')
      .then(results => {
        expect(results[0]).toBe('L');
        done();
      });
  });

  it('can pass options to a distinct query', done => {
    CoreManager.setQueryController({
      find() {},
      aggregate(className, params, options) {
        expect(className).toBe('Item');
        expect(params).toEqual({
          distinct: 'size',
          where: {
            size: 'small',
          },
        });
        expect(options.useMasterKey).toEqual(true);
        expect(options.sessionToken).toEqual('1234');
        expect(options.requestTask).toBeDefined();
        return Promise.resolve({
          results: ['L'],
        });
      },
    });

    const q = new ParseQuery('Item');
    q.equalTo('size', 'small')
      .distinct('size', {
        sessionToken: '1234',
      })
      .then(results => {
        expect(results[0]).toBe('L');
        done();
      });
  });

  it('can pass options to a distinct query with hint', done => {
    CoreManager.setQueryController({
      find() {},
      aggregate(className, params, options) {
        expect(className).toBe('Item');
        expect(params).toEqual({
          distinct: 'size',
          where: {
            size: 'small',
          },
          hint: '_id_',
        });
        expect(options.useMasterKey).toEqual(true);
        expect(options.sessionToken).toEqual('1234');
        expect(options.requestTask).toBeDefined();
        return Promise.resolve({
          results: ['L'],
        });
      },
    });

    const q = new ParseQuery('Item');
    q.equalTo('size', 'small')
      .hint('_id_')
      .distinct('size', {
        sessionToken: '1234',
      })
      .then(results => {
        expect(results[0]).toBe('L');
        done();
      });
  });

  it('can issue a query to the controller', () => {
    const q = new ParseQuery('Item');
    q.readPreference('PRIMARY', 'SECONDARY', 'SECONDARY_PREFERRED');
    const json = q.toJSON();
    expect(json).toEqual({
      where: {},
      readPreference: 'PRIMARY',
      includeReadPreference: 'SECONDARY',
      subqueryReadPreference: 'SECONDARY_PREFERRED',
    });
    const query = ParseQuery.fromJSON('Item', json);
    expect(query._readPreference).toBe('PRIMARY');
    expect(query._includeReadPreference).toBe('SECONDARY');
    expect(query._subqueryReadPreference).toBe('SECONDARY_PREFERRED');
  });

  it('can issue an aggregate query with array pipeline', done => {
    const pipeline = [{ group: { objectId: '$name' } }];
    CoreManager.setQueryController({
      find() {},
      aggregate(className, params, options) {
        expect(className).toBe('Item');
        expect(params.pipeline).toEqual([{ group: { objectId: '$name' } }]);
        expect(options.useMasterKey).toEqual(true);
        expect(options.requestTask).toBeDefined();
        return Promise.resolve({
          results: [],
        });
      },
    });

    const q = new ParseQuery('Item');
    q.aggregate(pipeline).then(results => {
      expect(results).toEqual([]);
      done();
    });
  });

  it('aggregate query array pipeline with equalTo', done => {
    const pipeline = [{ group: { objectId: '$name' } }];
    MockRESTController.request.mockImplementationOnce(() => {
      return Promise.resolve({
        results: [],
      });
    });
    const q = new ParseQuery('Item');
    q.equalTo('name', 'foo');
    q.aggregate(pipeline).then(results => {
      expect(results).toEqual([]);
      done();
    });
  });

  it('aggregate query object pipeline with equalTo', done => {
    const pipeline = {
      group: { objectId: '$name' },
    };
    MockRESTController.request.mockImplementationOnce(() => {
      return Promise.resolve({
        results: [],
      });
    });
    const q = new ParseQuery('Item');
    q.equalTo('name', 'foo');
    q.aggregate(pipeline).then(results => {
      expect(results).toEqual([]);
      done();
    });
  });

  it('can issue an aggregate query with object pipeline', done => {
    const pipeline = {
      group: { objectId: '$name' },
    };
    CoreManager.setQueryController({
      find() {},
      aggregate(className, params, options) {
        expect(className).toBe('Item');
        expect(params.pipeline).toEqual({ group: { objectId: '$name' } });
        expect(options.useMasterKey).toEqual(true);
        expect(options.requestTask).toBeDefined();
        return Promise.resolve({
          results: [],
        });
      },
    });

    const q = new ParseQuery('Item');
    q.aggregate(pipeline).then(results => {
      expect(results).toEqual([]);
      done();
    });
  });

  it('cannot issue an aggregate query with invalid pipeline', done => {
    const pipeline = 1234;
    CoreManager.setQueryController({
      find() {},
      aggregate(className, params, options) {
        expect(className).toBe('Item');
        expect(params).toEqual({
          group: { objectId: '$name' },
        });
        expect(options.useMasterKey).toEqual(true);
        expect(options.requestTask).toBeDefined();
        return Promise.resolve({
          results: [],
        });
      },
    });

    try {
      const q = new ParseQuery('Item');
      q.aggregate(pipeline).then(() => {});
    } catch (e) {
      done();
    }
  });

  it('can pass options to an aggregate query', done => {
    const pipeline = [{ group: { objectId: '$name' } }];
    CoreManager.setQueryController({
      find() {},
      aggregate(className, params, options) {
        expect(className).toBe('Item');
        expect(params.pipeline).toEqual([{ group: { objectId: '$name' } }]);
        expect(options.useMasterKey).toEqual(true);
        expect(options.sessionToken).toEqual('1234');
        return Promise.resolve({
          results: [],
        });
      },
    });

    const q = new ParseQuery('Item');
    q.aggregate(pipeline, {
      sessionToken: '1234',
    }).then(results => {
      expect(results).toEqual([]);
      done();
    });
  });

  it('can issue an aggregate query with read preference', async () => {
    // Override controller
    CoreManager.setQueryController({
      find() {},
      aggregate(className, params, options) {
        expect(className).toBe('Item');
        expect(params.readPreference).toEqual('SECONDARY');
        expect(options.useMasterKey).toEqual(true);
        return Promise.resolve({
          results: [],
        });
      },
    });
    // Query
    const q = new ParseQuery('Item');
    q.readPreference('SECONDARY');
    const results = await q.aggregate([], { sessionToken: '1234' });
    // Validate
    expect(results).toEqual([]);
  });

  it('can pass options to an aggregate query with hint', done => {
    const pipeline = [{ group: { objectId: '$name' } }];
    CoreManager.setQueryController({
      find() {},
      aggregate(className, params, options) {
        expect(className).toBe('Item');
        expect(params.pipeline).toEqual([{ group: { objectId: '$name' } }]);
        expect(params.hint).toEqual('_id_');
        expect(options.useMasterKey).toEqual(true);
        expect(options.sessionToken).toEqual('1234');
        return Promise.resolve({
          results: [],
        });
      },
    });

    const q = new ParseQuery('Item');
    q.hint('_id_')
      .aggregate(pipeline, {
        sessionToken: '1234',
      })
      .then(results => {
        expect(results).toEqual([]);
        done();
      });
  });

  it('can cancel query', async () => {
    const mockRequestTask = {
      abort: () => {},
    };

    CoreManager.setQueryController({
      find: function (name, params, options) {
        options.requestTask(mockRequestTask);
        return Promise.resolve({
          results: [],
        });
      },
      aggregate: () => {},
    });
    const query = new ParseQuery('TestCancel');
    expect(query._xhrRequest).toBeDefined();
    expect(query._xhrRequest.task).toBe(null);
    expect(query._xhrRequest.onchange()).toBeUndefined();

    jest.spyOn(mockRequestTask, 'abort');
    query.cancel();
    expect(mockRequestTask.abort).toHaveBeenCalledTimes(0);

    await query.find();

    expect(query._xhrRequest.task).toEqual(null);
    query.cancel();
    expect(mockRequestTask.abort).toHaveBeenCalledTimes(1);
  });

  it('selecting sub-objects does not inject objects when sub-object does not exist', done => {
    jest.dontMock('../ParseObject');
    jest.resetModules();
    ParseObject = require('../ParseObject').default;
    CoreManager = require('../CoreManager');
    ParseQuery = require('../ParseQuery').default;

    ParseObject.enableSingleInstance();

    const objectToReturn = {
      objectId: 'T01',
      name: 'Name',
      tbd: 'exists',
      className: 'Thing',
      createdAt: '2017-01-10T10:00:00Z',
    };

    CoreManager.setQueryController({
      aggregate() {},
      find() {
        return Promise.resolve({
          results: [objectToReturn],
        });
      },
    });

    const q = new ParseQuery('Thing');
    q.select('other', 'tbd', 'subObject.key1');
    let testObject;
    q
      .find()
      .then(results => {
        testObject = results[0];

        expect(testObject.get('name')).toBe('Name');
        expect(testObject.has('other')).toBe(false);
        expect(testObject.has('subObject')).toBe(false);
      })
      .then(
        () => {
          done();
        },
        error => {
          done.fail(error);
        }
      );
  });

  it('removes missing sub objects from the cached object when they are selected', done => {
    jest.dontMock('../ParseObject');
    jest.resetModules();
    ParseObject = require('../ParseObject').default;
    CoreManager = require('../CoreManager');
    ParseQuery = require('../ParseQuery').default;

    ParseObject.enableSingleInstance();

    let objectToReturn = {
      objectId: 'T01',
      name: 'Name',
      tbd: 'exists',
      className: 'Thing',
      subObject1: { foo: 'bar' },
      subObject2: { foo: 'bar' },
      subObject3: { foo: 'bar' },
      subObject5: { subSubObject: { foo: 'foo', bar: 'bar' } },
      createdAt: '2017-01-10T10:00:00Z',
    };

    CoreManager.setQueryController({
      aggregate() {},
      find() {
        return Promise.resolve({
          results: [objectToReturn],
        });
      },
    });

    const q = new ParseQuery('Thing');
    let testObject;
    q
      .find()
      .then(results => {
        testObject = results[0];

        expect(testObject.has('subObject1')).toBe(true);
        expect(testObject.has('subObject2')).toBe(true);
        expect(testObject.has('subObject3')).toBe(true);
        expect(testObject.has('subObject4')).toBe(false);

        const q2 = new ParseQuery('Thing');
        q2.select(
          'name',
          'subObject1',
          'subObject2.foo',
          'subObject4.foo',
          'subObject5.subSubObject.foo'
        );
        objectToReturn = {
          objectId: 'T01',
          name: 'Name',
          subObject4: { foo: 'bar' },
          subObject5: { subSubObject: {} },
        };
        return q2.find();
      })
      .then(() => {
        expect(testObject.has('subObject1')).toBe(false); //selected and not returned
        expect(testObject.has('subObject2')).toBe(false); //selected and not returned
        expect(testObject.has('subObject3')).toBe(true); //not selected, so should still be there
        expect(testObject.has('subObject4')).toBe(true); //selected and just added
        expect(testObject.has('subObject5')).toBe(true);
        expect(testObject.get('subObject5').subSubObject).toBeDefined();
        expect(testObject.get('subObject5').subSubObject.bar).toBeDefined(); //not selected but a sibiling was, so should still be there
      })
      .then(
        () => {
          done();
        },
        error => {
          done.fail(error);
        }
      );
  });

  it('full text search', () => {
    const query = new ParseQuery('Item');
    query.fullText('size', 'small');

    expect(query.toJSON()).toEqual({
      where: {
        size: {
          $text: {
            $search: {
              $term: 'small',
            },
          },
        },
      },
    });
  });

  it('full text search sort', () => {
    const query = new ParseQuery('Item');
    query.fullText('size', 'medium');
    query.ascending('$score');
    query.select('$score');

    expect(query.toJSON()).toEqual({
      where: {
        size: {
          $text: {
            $search: {
              $term: 'medium',
            },
          },
        },
      },
      keys: '$score',
      order: '$score',
    });
  });

  it('full text search key required', done => {
    const query = new ParseQuery('Item');
    expect(() => query.fullText()).toThrow('A key is required.');
    done();
  });

  it('full text search value required', done => {
    const query = new ParseQuery('Item');
    expect(() => query.fullText('key')).toThrow('A search term is required');
    done();
  });

  it('full text search value must be string', done => {
    const query = new ParseQuery('Item');
    expect(() => query.fullText('key', [])).toThrow(
      'The value being searched for must be a string.'
    );
    done();
  });

  it('full text search invalid option', done => {
    const query = new ParseQuery('Item');
    expect(() => query.fullText('size', 'medium', { unknown: 'throwOption' })).toThrow(
      'Unknown option: unknown'
    );
    done();
  });

  it('full text search with all parameters', () => {
    const query = new ParseQuery('Item');

    query.fullText('size', 'medium', {
      language: 'en',
      caseSensitive: false,
      diacriticSensitive: true,
    });

    expect(query.toJSON()).toEqual({
      where: {
        size: {
          $text: {
            $search: {
              $term: 'medium',
              $language: 'en',
              $caseSensitive: false,
              $diacriticSensitive: true,
            },
          },
        },
      },
    });
  });

  it('add the score for the full text search', () => {
    const query = new ParseQuery('Item');

    query.fullText('size', 'medium', { language: 'fr' });
    query.sortByTextScore();

    expect(query.toJSON()).toEqual({
      where: {
        size: {
          $text: {
            $search: {
              $term: 'medium',
              $language: 'fr',
            },
          },
        },
      },
      keys: '$score',
      order: '$score',
    });
  });
});

describe('ParseQuery LocalDatastore', () => {
  beforeEach(() => {
    CoreManager.setLocalDatastore(mockLocalDatastore);
    jest.clearAllMocks();
  });

  it('can query from local datastore', () => {
    mockLocalDatastore.checkIfEnabled.mockImplementationOnce(() => true);

    const q = new ParseQuery('Item');
    expect(q._queriesLocalDatastore).toBe(false);
    expect(q._localDatastorePinName).toBe(null);
    q.fromLocalDatastore();
    expect(q._queriesLocalDatastore).toBe(true);
    expect(q._localDatastorePinName).toBe(null);
  });

  it('can query from default pin', () => {
    mockLocalDatastore.checkIfEnabled.mockImplementationOnce(() => true);

    const q = new ParseQuery('Item');
    expect(q._queriesLocalDatastore).toBe(false);
    expect(q._localDatastorePinName).toBe(null);
    q.fromPin();
    expect(q._queriesLocalDatastore).toBe(true);
    expect(q._localDatastorePinName).toBe(DEFAULT_PIN);
    const query = q.fromNetwork();
    expect(q._queriesLocalDatastore).toBe(false);
    expect(q._localDatastorePinName).toBe(null);
    expect(query).toEqual(q);
  });

  it('can query from pin with name', () => {
    mockLocalDatastore.checkIfEnabled.mockImplementationOnce(() => true);

    const q = new ParseQuery('Item');
    expect(q._queriesLocalDatastore).toBe(false);
    expect(q._localDatastorePinName).toBe(null);
    q.fromPinWithName('test_pin');
    expect(q._queriesLocalDatastore).toBe(true);
    expect(q._localDatastorePinName).toBe('test_pin');
  });

  it('cannot query from local datastore if disabled', () => {
    const q = new ParseQuery('Item');
    expect(q._queriesLocalDatastore).toBe(false);
    expect(q._localDatastorePinName).toBe(null);
    q.fromLocalDatastore();
    expect(q._queriesLocalDatastore).toBe(false);
    expect(q._localDatastorePinName).toBe(null);
  });

  it('can query from default pin if disabled', () => {
    const q = new ParseQuery('Item');
    expect(q._queriesLocalDatastore).toBe(false);
    expect(q._localDatastorePinName).toBe(null);
    q.fromPin();
    expect(q._queriesLocalDatastore).toBe(false);
    expect(q._localDatastorePinName).toBe(null);
  });

  it('can query from pin with name if disabled', () => {
    const q = new ParseQuery('Item');
    expect(q._queriesLocalDatastore).toBe(false);
    expect(q._localDatastorePinName).toBe(null);
    q.fromPinWithName('test_pin');
    expect(q._queriesLocalDatastore).toBe(false);
    expect(q._localDatastorePinName).toBe(null);
  });

  it('can query offline', async () => {
    const obj1 = {
      className: 'Item',
      objectId: 'objectId1',
      count: 2,
    };

    const obj2 = {
      className: 'Item',
      objectId: 'objectId2',
    };

    const obj3 = {
      className: 'Unknown',
      objectId: 'objectId3',
    };

    mockLocalDatastore._serializeObjectsFromPinName.mockImplementationOnce(() => [
      obj1,
      obj2,
      obj3,
    ]);

    mockLocalDatastore.checkIfEnabled.mockImplementationOnce(() => true);

    const q = new ParseQuery('Item');
    q.equalTo('count', 2);
    q.fromLocalDatastore();
    const results = await q.find();
    expect(results[0].id).toEqual(obj1.objectId);
  });

  it('can query offline with localId', async () => {
    const obj1 = {
      className: 'Item',
      _localId: 'local0',
      count: 2,
    };

    const obj2 = {
      className: 'Item',
      objectId: 'objectId2',
    };

    const obj3 = {
      className: 'Unknown',
      objectId: 'objectId3',
    };

    mockLocalDatastore._serializeObjectsFromPinName.mockImplementationOnce(() => [
      obj1,
      obj2,
      obj3,
    ]);

    mockLocalDatastore.checkIfEnabled.mockImplementationOnce(() => true);

    const q = new ParseQuery('Item');
    q.equalTo('count', 2);
    q.fromLocalDatastore();
    const results = await q.find();
    expect(results[0]._localId).toEqual(obj1._localId);
  });

  it('can query offline first', async () => {
    const obj1 = {
      className: 'Item',
      objectId: 'objectId1',
      count: 2,
    };

    const obj2 = {
      className: 'Item',
      objectId: 'objectId2',
    };

    const obj3 = {
      className: 'Unknown',
      objectId: 'objectId3',
    };

    mockLocalDatastore._serializeObjectsFromPinName.mockImplementationOnce(() => [
      obj1,
      obj2,
      obj3,
    ]);

    mockLocalDatastore.checkIfEnabled.mockImplementationOnce(() => true);

    let q = new ParseQuery('Item');
    q.fromLocalDatastore();
    let result = await q.first();
    expect(result.id).toEqual(obj1.objectId);

    jest.clearAllMocks();
    mockLocalDatastore._serializeObjectsFromPinName.mockImplementationOnce(() => []);

    mockLocalDatastore.checkIfEnabled.mockImplementationOnce(() => true);

    q = new ParseQuery('Item');
    q.fromLocalDatastore();
    result = await q.first();
    expect(result).toEqual(undefined);
  });

  it('can query offline sort', async () => {
    const obj1 = {
      className: 'Item',
      objectId: 'objectId1',
      password: 123,
      number: 2,
      createdAt: new Date('2018-08-10T00:00:00.000Z'),
      updatedAt: new Date('2018-08-10T00:00:00.000Z'),
    };

    const obj2 = {
      className: 'Item',
      objectId: 'objectId2',
      password: 123,
      number: 3,
      createdAt: new Date('2018-08-11T00:00:00.000Z'),
      updatedAt: new Date('2018-08-11T00:00:00.000Z'),
    };

    const obj3 = {
      className: 'Item',
      objectId: 'objectId3',
      password: 123,
      number: 4,
      createdAt: new Date('2018-08-12T00:00:00.000Z'),
      updatedAt: new Date('2018-08-12T00:00:00.000Z'),
    };

    const obj4 = {
      className: 'Item',
      objectId: 'objectId4',
      password: 123,
      number: 4,
      createdAt: new Date('2018-08-12T00:00:00.000Z'),
      updatedAt: new Date('2018-08-12T00:00:00.000Z'),
    };

    mockLocalDatastore._serializeObjectsFromPinName.mockImplementation(() => [
      obj1,
      obj3,
      obj2,
      obj4,
    ]);

    mockLocalDatastore.checkIfEnabled.mockImplementation(() => true);

    let q = new ParseQuery('Item');
    q.ascending('number');
    q.fromLocalDatastore();
    let results = await q.find();
    expect(results[0].get('number')).toEqual(2);
    expect(results[1].get('number')).toEqual(3);
    expect(results[2].get('number')).toEqual(4);
    expect(results[3].get('number')).toEqual(4);

    q = new ParseQuery('Item');
    q.descending('number');
    q.fromLocalDatastore();
    results = await q.find();
    expect(results[0].get('number')).toEqual(4);
    expect(results[1].get('number')).toEqual(4);
    expect(results[2].get('number')).toEqual(3);
    expect(results[3].get('number')).toEqual(2);

    q = new ParseQuery('Item');
    q.ascending('_created_at');
    q.fromLocalDatastore();
    results = await q.find();
    expect(results[0].get('number')).toEqual(2);
    expect(results[1].get('number')).toEqual(3);
    expect(results[2].get('number')).toEqual(4);

    q = new ParseQuery('Item');
    q.ascending('_updated_at');
    q.fromLocalDatastore();
    results = await q.find();
    expect(results[0].get('number')).toEqual(2);
    expect(results[1].get('number')).toEqual(3);
    expect(results[2].get('number')).toEqual(4);

    q = new ParseQuery('Item');
    q.descending('password');
    q.fromLocalDatastore();
    try {
      results = await q.find();
    } catch (e) {
      expect(e.message).toEqual('Invalid Key: password');
    }
  });

  it('can query offline sort multiple', async () => {
    const obj1 = {
      className: 'Item',
      objectId: 'objectId1',
      password: 123,
      number: 3,
      string: 'a',
    };

    const obj2 = {
      className: 'Item',
      objectId: 'objectId2',
      number: 1,
      string: 'b',
    };

    const obj3 = {
      className: 'Item',
      objectId: 'objectId3',
      number: 3,
      string: 'c',
    };

    const obj4 = {
      className: 'Item',
      objectId: 'objectId4',
      number: 2,
      string: 'd',
    };

    mockLocalDatastore._serializeObjectsFromPinName.mockImplementation(() => [
      obj1,
      obj2,
      obj3,
      obj4,
    ]);

    mockLocalDatastore.checkIfEnabled.mockImplementation(() => true);

    let q = new ParseQuery('Item');
    q.ascending('number,string');
    q.fromLocalDatastore();
    let results = await q.find();
    expect(results[0].get('number')).toEqual(1);
    expect(results[1].get('number')).toEqual(2);
    expect(results[2].get('number')).toEqual(3);
    expect(results[3].get('number')).toEqual(3);
    expect(results[0].get('string')).toEqual('b');
    expect(results[1].get('string')).toEqual('d');
    expect(results[2].get('string')).toEqual('a');
    expect(results[3].get('string')).toEqual('c');

    q = new ParseQuery('Item');
    q.ascending('number').addDescending('string');
    q.fromLocalDatastore();
    results = await q.find();
    expect(results[0].get('number')).toEqual(1);
    expect(results[1].get('number')).toEqual(2);
    expect(results[2].get('number')).toEqual(3);
    expect(results[3].get('number')).toEqual(3);
    expect(results[0].get('string')).toEqual('b');
    expect(results[1].get('string')).toEqual('d');
    expect(results[2].get('string')).toEqual('c');
    expect(results[3].get('string')).toEqual('a');

    q = new ParseQuery('Item');
    q.descending('number,string');
    q.fromLocalDatastore();
    results = await q.find();

    expect(results[0].get('number')).toEqual(3);
    expect(results[1].get('number')).toEqual(3);
    expect(results[2].get('number')).toEqual(2);
    expect(results[3].get('number')).toEqual(1);
    expect(results[0].get('string')).toEqual('c');
    expect(results[1].get('string')).toEqual('a');
    expect(results[2].get('string')).toEqual('d');
    expect(results[3].get('string')).toEqual('b');

    q = new ParseQuery('Item');
    q.descending('number').addAscending('string');
    q.fromLocalDatastore();
    results = await q.find();

    expect(results[0].get('number')).toEqual(3);
    expect(results[1].get('number')).toEqual(3);
    expect(results[2].get('number')).toEqual(2);
    expect(results[3].get('number')).toEqual(1);
    expect(results[0].get('string')).toEqual('a');
    expect(results[1].get('string')).toEqual('c');
    expect(results[2].get('string')).toEqual('d');
    expect(results[3].get('string')).toEqual('b');
  });

  it('can query offline limit', async () => {
    const obj1 = {
      className: 'Item',
      objectId: 'objectId1',
      number: 3,
      string: 'a',
    };

    const obj2 = {
      className: 'Item',
      objectId: 'objectId2',
      number: 1,
      string: 'b',
    };

    mockLocalDatastore._serializeObjectsFromPinName.mockImplementation(() => [obj1, obj2]);

    mockLocalDatastore.checkIfEnabled.mockImplementation(() => true);

    let q = new ParseQuery('Item');
    q.limit(0);
    q.fromLocalDatastore();
    let results = await q.find();
    expect(results.length).toEqual(2);

    q = new ParseQuery('Item');
    q.limit(1);
    q.fromLocalDatastore();
    results = await q.find();
    expect(results.length).toEqual(1);

    q = new ParseQuery('Item');
    q.limit(2);
    q.fromLocalDatastore();
    results = await q.find();
    expect(results.length).toEqual(2);

    q = new ParseQuery('Item');
    q.limit(3);
    q.fromLocalDatastore();
    results = await q.find();
    expect(results.length).toEqual(2);

    q = new ParseQuery('Item');
    q.limit(-1);
    q.fromLocalDatastore();
    results = await q.find();
    expect(results.length).toEqual(2);
  });

  it('can query offline skip', async () => {
    const obj1 = {
      className: 'Item',
      objectId: 'objectId1',
      password: 123,
      number: 3,
      string: 'a',
    };

    const obj2 = {
      className: 'Item',
      objectId: 'objectId2',
      number: 1,
      string: 'b',
    };

    const obj3 = {
      className: 'Item',
      objectId: 'objectId3',
      number: 2,
      string: 'c',
    };

    const objects = [obj1, obj2, obj3];
    mockLocalDatastore._serializeObjectsFromPinName.mockImplementation(() => objects);

    mockLocalDatastore.checkIfEnabled.mockImplementation(() => true);

    let q = new ParseQuery('Item');
    q.skip(0);
    q.fromLocalDatastore();
    let results = await q.find();
    expect(results.length).toEqual(3);

    q = new ParseQuery('Item');
    q.skip(1);
    q.fromLocalDatastore();
    results = await q.find();
    expect(results.length).toEqual(2);

    q = new ParseQuery('Item');
    q.skip(3);
    q.fromLocalDatastore();
    results = await q.find();
    expect(results.length).toEqual(0);

    q = new ParseQuery('Item');
    q.skip(4);
    q.fromLocalDatastore();
    results = await q.find();
    expect(results.length).toEqual(0);

    q = new ParseQuery('Item');
    q.limit(1);
    q.skip(2);
    q.fromLocalDatastore();
    results = await q.find();
    expect(results.length).toEqual(1);

    q = new ParseQuery('Item');
    q.limit(1);
    q.skip(1);
    q.fromLocalDatastore();
    results = await q.find();
    expect(results.length).toEqual(1);

    q = new ParseQuery('Item');
    q.limit(2);
    q.skip(1);
    q.fromLocalDatastore();
    results = await q.find();
    expect(results.length).toEqual(2);
  });

  it('can query offline withCount, skip and limit', async () => {
    const obj1 = {
      className: 'Item',
      objectId: 'objectId1',
      password: 123,
      number: 3,
      string: 'a',
    };

    const obj2 = {
      className: 'Item',
      objectId: 'objectId2',
      number: 1,
      string: 'b',
    };

    const obj3 = {
      className: 'Item',
      objectId: 'objectId3',
      number: 2,
      string: 'c',
    };

    const objects = [obj1, obj2, obj3];
    mockLocalDatastore._serializeObjectsFromPinName.mockImplementation(() => objects);

    mockLocalDatastore.checkIfEnabled.mockImplementation(() => true);

    let q = new ParseQuery('Item');
    q.skip(0);
    q.withCount(true);
    q.fromLocalDatastore();
    let result = await q.find();
    expect(result.results.length).toEqual(3);
    expect(result.count).toEqual(3);

    q = new ParseQuery('Item');
    q.skip(1);
    q.withCount(true);
    q.fromLocalDatastore();
    result = await q.find();
    expect(result.results.length).toEqual(2);
    expect(result.count).toEqual(3);

    q = new ParseQuery('Item');
    q.skip(3);
    q.withCount(true);
    q.fromLocalDatastore();
    result = await q.find();
    expect(result.results.length).toEqual(0);
    expect(result.count).toEqual(3);

    q = new ParseQuery('Item');
    q.withCount(true);
    q.skip(4);
    q.fromLocalDatastore();
    result = await q.find();
    expect(result.results.length).toEqual(0);
    expect(result.count).toEqual(3);

    q = new ParseQuery('Item');
    q.limit(1);
    q.skip(2);
    q.withCount(true);
    q.fromLocalDatastore();
    result = await q.find();
    expect(result.results.length).toEqual(1);
    expect(result.count).toEqual(3);

    q = new ParseQuery('Item');
    q.limit(1);
    q.skip(1);
    q.withCount(true);
    q.fromLocalDatastore();
    result = await q.find();
    expect(result.results.length).toEqual(1);
    expect(result.count).toEqual(3);

    q = new ParseQuery('Item');
    q.limit(2);
    q.skip(1);
    q.withCount(true);
    q.fromLocalDatastore();
    result = await q.find();
    expect(result.results.length).toEqual(2);
    expect(result.count).toEqual(3);
  });

  it('can query offline select keys', async () => {
    const obj1 = {
      className: 'Item',
      objectId: 'objectId1',
      foo: 'baz',
      bar: 1,
    };

    mockLocalDatastore._serializeObjectsFromPinName.mockImplementation(() => [obj1]);

    mockLocalDatastore.checkIfEnabled.mockImplementation(() => true);

    const q = new ParseQuery('Item');
    q.select('foo');
    q.fromLocalDatastore();
    const results = await q.find();
    expect(results[0].get('foo')).toEqual('baz');
  });

  it('can subscribe to query if client is already open', async () => {
    const mockLiveQueryClient = {
      shouldOpen: function () {
        return false;
      },
      subscribe: function (query, sessionToken) {
        const subscription = new LiveQuerySubscription('0', query, sessionToken);
        subscription.subscribePromise.resolve();
        return subscription;
      },
    };
    CoreManager.set('UserController', {
      currentUserAsync() {
        return Promise.resolve({
          getSessionToken() {
            return 'token';
          },
        });
      },
    });
    CoreManager.set('LiveQueryController', {
      getDefaultLiveQueryClient() {
        return Promise.resolve(mockLiveQueryClient);
      },
    });
    const query = new ParseQuery('TestObject');
    const subscription = await query.subscribe();
    expect(subscription.id).toBe('0');
    expect(subscription.sessionToken).toBe('token');
    expect(subscription.query).toEqual(query);
  });

  it('can subscribe to query if client is not open', async () => {
    const mockLiveQueryClient = {
      shouldOpen: function () {
        return true;
      },
      open: function () {},
      subscribe: function (query, sessionToken) {
        const subscription = new LiveQuerySubscription('0', query, sessionToken);
        subscription.subscribePromise.resolve();
        return subscription;
      },
    };
    CoreManager.set('UserController', {
      currentUserAsync() {
        return Promise.resolve({
          getSessionToken() {
            return 'token';
          },
        });
      },
    });
    CoreManager.set('LiveQueryController', {
      getDefaultLiveQueryClient() {
        return Promise.resolve(mockLiveQueryClient);
      },
    });
    const query = new ParseQuery('TestObject');
    const subscription = await query.subscribe();
    expect(subscription.id).toBe('0');
    expect(subscription.sessionToken).toBe('token');
    expect(subscription.query).toEqual(query);
  });

  it('can subscribe to query without sessionToken', async () => {
    const mockLiveQueryClient = {
      shouldOpen: function () {
        return true;
      },
      open: function () {},
      subscribe: function (query, sessionToken) {
        const subscription = new LiveQuerySubscription('0', query, sessionToken);
        subscription.subscribePromise.resolve();
        return subscription;
      },
    };
    CoreManager.set('UserController', {
      currentUserAsync() {
        return Promise.resolve(null);
      },
    });
    CoreManager.set('LiveQueryController', {
      getDefaultLiveQueryClient() {
        return Promise.resolve(mockLiveQueryClient);
      },
    });
    const query = new ParseQuery('TestObject');
    const subscription = await query.subscribe();
    expect(subscription.id).toBe('0');
    expect(subscription.sessionToken).toBeUndefined();
    expect(subscription.query).toEqual(query);
  });

  it('can subscribe to query with sessionToken parameter', async () => {
    const mockLiveQueryClient = {
      shouldOpen: function () {
        return true;
      },
      open: function () {},
      subscribe: function (query, sessionToken) {
        const subscription = new LiveQuerySubscription('0', query, sessionToken);
        subscription.subscribePromise.resolve();
        return subscription;
      },
    };
    CoreManager.set('UserController', {
      currentUserAsync() {
        return Promise.resolve(null);
      },
    });
    CoreManager.set('LiveQueryController', {
      getDefaultLiveQueryClient() {
        return Promise.resolve(mockLiveQueryClient);
      },
    });
    const query = new ParseQuery('TestObject');
    const subscription = await query.subscribe('r:test');
    expect(subscription.id).toBe('0');
    expect(subscription.sessionToken).toBe('r:test');
    expect(subscription.query).toEqual(query);
  });

  it('can query with dot notation', async () => {
    CoreManager.setQueryController({
      aggregate() {},
      find() {
        return Promise.resolve({
          results: [{ objectId: 'I1', size: 'small', name: 'Product 3' }],
        });
      },
    });
    const object = await new ParseQuery('Item').equalTo('size', 'small').first();
    expect(object.id).toBe('I1');
    expect(object.bind.size).toBe('small');
    expect(object.bind.name).toBe('Product 3');
  });
});