ParseGeoPointTest.js

'use strict';

const assert = require('assert');
const Parse = require('../../node');

describe('Geo Point', () => {
  beforeEach(async () => {
    Parse.CoreManager.set('REQUEST_ATTEMPT_LIMIT', 1);

    const sacramento = new TestPoint();
    sacramento.set('location', new Parse.GeoPoint(38.52, -121.5));
    sacramento.set('name', 'Sacramento');

    const honolulu = new TestPoint();
    honolulu.set('location', new Parse.GeoPoint(21.35, -157.93));
    honolulu.set('name', 'Honolulu');

    const sf = new TestPoint();
    sf.set('location', new Parse.GeoPoint(37.75, -122.68));
    sf.set('name', 'San Francisco');

    await Parse.Object.saveAll([sacramento, honolulu, sf]);
  });

  it('can save geo points', done => {
    const point = new Parse.GeoPoint(44.0, -11.0);
    const obj = new TestObject();
    obj.set('location', point);
    obj.set('name', 'Ferndale');
    obj
      .save()
      .then(() => {
        const query = new Parse.Query(TestObject);
        return query.get(obj.id);
      })
      .then(o => {
        assert(o.get('location'));
        assert.equal(o.get('location').latitude, 44.0);
        assert.equal(o.get('location').longitude, -11.0);
        done();
      });
  });

  it('can only store one geo point per object', done => {
    const point = new Parse.GeoPoint(20, 20);
    const obj = new Container();
    obj.set('locationOne', point);
    obj.set('locationTwo', point);
    obj
      .save()
      .then(done.fail)
      .catch(() => {
        done();
      });
  });

  it('can sequence a line of points by distance - without unsorted parameter', done => {
    const line = [];
    for (let i = 0; i < 10; i++) {
      const obj = new TestObject();
      const point = new Parse.GeoPoint(i * 4 - 12, i * 3.2 - 11);
      obj.set('location', point);
      obj.set('construct', 'line');
      obj.set('seq', i);
      line.push(obj);
    }
    Parse.Object.saveAll(line)
      .then(() => {
        const query = new Parse.Query(TestObject);
        const point = new Parse.GeoPoint(24, 19);
        query.equalTo('construct', 'line');
        query.withinMiles('location', point, 10000);
        return query.find();
      })
      .then(results => {
        assert.equal(results.length, 10);
        assert.equal(results[0].get('seq'), 9);
        assert.equal(results[3].get('seq'), 6);
        done();
      });
  });

  it('can sequence a line of points by distance - with unsorted parameter', done => {
    const line = [];
    for (let i = 0; i < 10; i++) {
      const obj = new TestObject();
      const point = new Parse.GeoPoint(i * 4 - 12, i * 3.2 - 11);
      obj.set('location', point);
      obj.set('construct', 'line_unsorted');
      obj.set('seq', i);
      line.push(obj);
    }
    Parse.Object.saveAll(line)
      .then(() => {
        const query = new Parse.Query(TestObject);
        const point = new Parse.GeoPoint(24, 19);
        query.equalTo('construct', 'line_unsorted');
        query.withinMiles('location', point, 10000, true);
        return query.find();
      })
      .then(results => {
        assert.equal(results.length, 10);
        assert.equal(results[0].get('seq'), 9);
        assert.equal(results[3].get('seq'), 6);
        done();
      });
  });

  it('can query within large distances', done => {
    const objects = [];
    for (let i = 0; i < 3; i++) {
      const obj = new TestObject();
      const point = new Parse.GeoPoint(0, i * 45);
      obj.set('location', point);
      obj.set('construct', 'large_dist');
      obj.set('index', i);
      objects.push(obj);
    }
    Parse.Object.saveAll(objects)
      .then(() => {
        const query = new Parse.Query(TestObject);
        const point = new Parse.GeoPoint(1, -1);
        query.equalTo('construct', 'large_dist');
        query.withinRadians('location', point, 3.14);
        return query.find();
      })
      .then(results => {
        assert.equal(results.length, 3);
        done();
      });
  });

  it('can query within medium distances', done => {
    const objects = [];
    for (let i = 0; i < 3; i++) {
      const obj = new TestObject();
      const point = new Parse.GeoPoint(0, i * 45);
      obj.set('location', point);
      obj.set('construct', 'medium_dist');
      obj.set('index', i);
      objects.push(obj);
    }
    Parse.Object.saveAll(objects)
      .then(() => {
        const query = new Parse.Query(TestObject);
        const point = new Parse.GeoPoint(1, -1);
        query.equalTo('construct', 'medium_dist');
        query.withinRadians('location', point, 3.14 * 0.5);
        return query.find();
      })
      .then(results => {
        assert.equal(results.length, 2);
        assert.equal(results[0].get('index'), 0);
        assert.equal(results[1].get('index'), 1);
        done();
      });
  });

  it('can query within small distances', done => {
    const objects = [];
    for (let i = 0; i < 3; i++) {
      const obj = new TestObject();
      const point = new Parse.GeoPoint(0, i * 45);
      obj.set('location', point);
      obj.set('construct', 'small_dist');
      obj.set('index', i);
      objects.push(obj);
    }
    Parse.Object.saveAll(objects)
      .then(() => {
        const query = new Parse.Query(TestObject);
        const point = new Parse.GeoPoint(1, -1);
        query.equalTo('construct', 'small_dist');
        query.withinRadians('location', point, 3.14 * 0.25);
        return query.find();
      })
      .then(results => {
        assert.equal(results.length, 1);
        assert.equal(results[0].get('index'), 0);
        done();
      });
  });

  it('can measure distance within km - everywhere', done => {
    const sfo = new Parse.GeoPoint(37.6189722, -122.3748889);
    const query = new Parse.Query(TestPoint);
    query.withinKilometers('location', sfo, 4000.0);
    query.find().then(results => {
      assert.equal(results.length, 3);
      done();
    });
  });

  it('can measure distance within km - california', done => {
    const sfo = new Parse.GeoPoint(37.6189722, -122.3748889);
    const query = new Parse.Query(TestPoint);
    query.withinKilometers('location', sfo, 3700.0);
    query.find().then(results => {
      assert.equal(results.length, 2);
      assert.equal(results[0].get('name'), 'San Francisco');
      assert.equal(results[1].get('name'), 'Sacramento');
      done();
    });
  });

  it('can measure distance within km - bay area', done => {
    const sfo = new Parse.GeoPoint(37.6189722, -122.3748889);
    const query = new Parse.Query(TestPoint);
    query.withinKilometers('location', sfo, 100.0);
    query.find().then(results => {
      assert.equal(results.length, 1);
      assert.equal(results[0].get('name'), 'San Francisco');
      done();
    });
  });

  it('can measure distance within km - mid peninsula', done => {
    const sfo = new Parse.GeoPoint(37.6189722, -122.3748889);
    const query = new Parse.Query(TestPoint);
    query.withinKilometers('location', sfo, 10.0);
    query.find().then(results => {
      assert.equal(results.length, 0);
      done();
    });
  });

  it('can measure distance within miles - everywhere', done => {
    const sfo = new Parse.GeoPoint(37.6189722, -122.3748889);
    const query = new Parse.Query(TestPoint);
    query.withinMiles('location', sfo, 2500.0);
    query.find().then(results => {
      assert.equal(results.length, 3);
      done();
    });
  });

  it('can measure distance within miles - california', done => {
    const sfo = new Parse.GeoPoint(37.6189722, -122.3748889);
    const query = new Parse.Query(TestPoint);
    query.withinMiles('location', sfo, 2200.0);
    query.find().then(results => {
      assert.equal(results.length, 2);
      assert.equal(results[0].get('name'), 'San Francisco');
      assert.equal(results[1].get('name'), 'Sacramento');
      done();
    });
  });

  it('can measure distance within miles - bay area', done => {
    const sfo = new Parse.GeoPoint(37.6189722, -122.3748889);
    const query = new Parse.Query(TestPoint);
    query.withinMiles('location', sfo, 75.0);
    query.find().then(results => {
      assert.equal(results.length, 1);
      assert.equal(results[0].get('name'), 'San Francisco');
      done();
    });
  });

  it('can measure distance within miles - mid peninsula', done => {
    const sfo = new Parse.GeoPoint(37.6189722, -122.3748889);
    const query = new Parse.Query(TestPoint);
    query.withinMiles('location', sfo, 10.0);
    query.find().then(results => {
      assert.equal(results.length, 0);
      done();
    });
  });

  it('can query within large distances unsorted', done => {
    const objects = [];
    for (let i = 0; i < 3; i++) {
      const obj = new TestObject();
      const point = new Parse.GeoPoint(0, i * 45);
      obj.set('location', point);
      obj.set('construct', 'large_dist_unsorted');
      obj.set('index', i);
      objects.push(obj);
    }
    Parse.Object.saveAll(objects)
      .then(() => {
        const query = new Parse.Query(TestObject);
        const point = new Parse.GeoPoint(1, -1);
        query.equalTo('construct', 'large_dist_unsorted');
        query.withinRadians('location', point, 3.14, false);
        return query.find();
      })
      .then(results => {
        assert.equal(results.length, 3);
        done();
      });
  });

  it('can query within medium distances unsorted', done => {
    const objects = [];
    for (let i = 0; i < 3; i++) {
      const obj = new TestObject();
      const point = new Parse.GeoPoint(0, i * 45);
      obj.set('location', point);
      obj.set('construct', 'medium_dist_unsorted');
      obj.set('index', i);
      objects.push(obj);
    }
    Parse.Object.saveAll(objects)
      .then(() => {
        const query = new Parse.Query(TestObject);
        const point = new Parse.GeoPoint(1, -1);
        query.equalTo('construct', 'medium_dist_unsorted');
        query.withinRadians('location', point, 3.14 * 0.5, false);
        return query.find();
      })
      .then(results => {
        assert.equal(results.length, 2);
        done();
      });
  });

  it('can query within small distances unsorted', done => {
    const objects = [];
    for (let i = 0; i < 3; i++) {
      const obj = new TestObject();
      const point = new Parse.GeoPoint(0, i * 45);
      obj.set('location', point);
      obj.set('construct', 'small_dist_unsorted');
      obj.set('index', i);
      objects.push(obj);
    }
    Parse.Object.saveAll(objects)
      .then(() => {
        const query = new Parse.Query(TestObject);
        const point = new Parse.GeoPoint(1, -1);
        query.equalTo('construct', 'small_dist_unsorted');
        query.withinRadians('location', point, 3.14 * 0.25, false);
        return query.find();
      })
      .then(results => {
        assert.equal(results.length, 1);
        assert.equal(results[0].get('index'), 0);
        done();
      });
  });

  it('can measure distance within km unsorted - everywhere', done => {
    const sfo = new Parse.GeoPoint(37.6189722, -122.3748889);
    const query = new Parse.Query(TestPoint);
    query.withinKilometers('location', sfo, 4000.0, false);
    query.find().then(results => {
      assert.equal(results.length, 3);
      done();
    });
  });

  it('can measure distance within km unsorted - california', done => {
    const sfo = new Parse.GeoPoint(37.6189722, -122.3748889);
    const query = new Parse.Query(TestPoint);
    query.withinKilometers('location', sfo, 3700.0, false);
    query.find().then(results => {
      assert.equal(results.length, 2);
      results.forEach(result => {
        assert.strictEqual(['San Francisco', 'Sacramento'].includes(result.get('name')), true);
      });
      done();
    });
  });

  it('can measure distance within km unsorted - bay area', done => {
    const sfo = new Parse.GeoPoint(37.6189722, -122.3748889);
    const query = new Parse.Query(TestPoint);
    query.withinKilometers('location', sfo, 100.0, false);
    query.find().then(results => {
      assert.equal(results.length, 1);
      assert.equal(results[0].get('name'), 'San Francisco');
      done();
    });
  });

  it('can measure distance within km unsorted - mid peninsula', done => {
    const sfo = new Parse.GeoPoint(37.6189722, -122.3748889);
    const query = new Parse.Query(TestPoint);
    query.withinKilometers('location', sfo, 10.0, false);
    query.find().then(results => {
      assert.equal(results.length, 0);
      done();
    });
  });

  it('can measure distance within miles unsorted - everywhere', done => {
    const sfo = new Parse.GeoPoint(37.6189722, -122.3748889);
    const query = new Parse.Query(TestPoint);
    query.withinMiles('location', sfo, 2500.0, false);
    query.find().then(results => {
      assert.equal(results.length, 3);
      done();
    });
  });

  it('can measure distance within miles unsorted - california', done => {
    const sfo = new Parse.GeoPoint(37.6189722, -122.3748889);
    const query = new Parse.Query(TestPoint);
    query.withinMiles('location', sfo, 2200.0, false);
    query.find().then(results => {
      assert.equal(results.length, 2);
      results.forEach(result => {
        assert.strictEqual(['San Francisco', 'Sacramento'].includes(result.get('name')), true);
      });
      done();
    });
  });

  it('can measure distance within miles unsorted - bay area', done => {
    const sfo = new Parse.GeoPoint(37.6189722, -122.3748889);
    const query = new Parse.Query(TestPoint);
    query.withinMiles('location', sfo, 75.0, false);
    query.find().then(results => {
      assert.equal(results.length, 1);
      assert.equal(results[0].get('name'), 'San Francisco');
      done();
    });
  });

  it('can measure distance within miles unsorted - mid peninsula', done => {
    const sfo = new Parse.GeoPoint(37.6189722, -122.3748889);
    const query = new Parse.Query(TestPoint);
    query.withinMiles('location', sfo, 10.0, false);
    query.find().then(results => {
      assert.equal(results.length, 0);
      done();
    });
  });

  it('supports withinPolygon open path', done => {
    const points = [
      new Parse.GeoPoint(37.85, -122.33),
      new Parse.GeoPoint(37.85, -122.9),
      new Parse.GeoPoint(37.68, -122.9),
      new Parse.GeoPoint(37.68, -122.33),
    ];
    const query = new Parse.Query(TestPoint);
    query.withinPolygon('location', points);
    query.find().then(results => {
      assert.equal(results.length, 1);
      done();
    });
  });

  it('supports withinPolygon closed path', done => {
    const points = [
      new Parse.GeoPoint(38.52, -121.5),
      new Parse.GeoPoint(37.75, -157.93),
      new Parse.GeoPoint(37.578072, -121.379914),
      new Parse.GeoPoint(38.52, -121.5),
    ];
    const query = new Parse.Query(TestPoint);
    query.withinPolygon('location', points);
    query.find().then(results => {
      assert.equal(results.length, 2);
      done();
    });
  });

  it('non array withinPolygon', done => {
    const query = new Parse.Query(TestPoint);
    query.withinPolygon('location', 1234);
    query.find().catch(err => {
      assert.equal(err.code, Parse.Error.INVALID_JSON);
      done();
    });
  });

  it('invalid array withinPolygon', done => {
    const query = new Parse.Query(TestPoint);
    query.withinPolygon('location', [1234]);
    query.find().catch(err => {
      assert.equal(err.code, Parse.Error.INVALID_JSON);
      done();
    });
  });

  it('minimum 3 points withinPolygon', async () => {
    const query = new Parse.Query(TestPoint);
    query.withinPolygon('location', []);
    try {
      await query.find();
    } catch (error) {
      assert.strictEqual(error.code, Parse.Error.INVALID_JSON);
    }
  });
});