ci: Improve test coverage (#2002)

src/ObjectStateMutations.js

@@ -150,7 +150,9 @@ export function estimateAttributes(
 function nestedSet(obj, key, value) {
   const path = key.split('.');
   for (let i = 0; i < path.length - 1; i++) {
-    if (!(path[i] in obj)) obj[path[i]] = {};
+    if (!(path[i] in obj)) {
+      obj[path[i]] = {};
+    }
     obj = obj[path[i]];
   }
   if (typeof value === 'undefined') {

src/OfflineQuery.js

@@ -538,7 +538,7 @@ function matchesKeyConstraints(className, object, objects, key, constraints) {
         const distance = point.radiansTo(centerPoint);
         return distance <= maxDistance;
       }
-      break;
+      return false;
     }
     case '$geoIntersects': {
       const polygon = new ParsePolygon(object[key].coordinates);

src/__tests__/LiveQueryClient-test.js

@@ -756,6 +756,21 @@ describe('LiveQueryClient', () => {
     spy.mockRestore();
   });
 
+  it('can handle WebSocket disconnect if already disconnected', async () => {
+    const liveQueryClient = new LiveQueryClient({
+      applicationId: 'applicationId',
+      serverURL: 'ws://test',
+      javascriptKey: 'javascriptKey',
+      masterKey: 'masterKey',
+      sessionToken: 'sessionToken',
+    });
+    const spy = jest.spyOn(liveQueryClient, '_handleReconnect');
+    liveQueryClient.state = 'disconnected';
+    liveQueryClient._handleWebSocketClose();
+    expect(liveQueryClient._handleReconnect).toHaveBeenCalledTimes(0);
+    spy.mockRestore();
+  });
+
   it('can subscribe', async () => {
     const liveQueryClient = new LiveQueryClient({
       applicationId: 'applicationId',
@@ -886,6 +901,31 @@ describe('LiveQueryClient', () => {
     expect(liveQueryClient.socket.send).toHaveBeenCalledTimes(0);
   });
 
+  it('cannot subscribe on connection error', async () => {
+    const liveQueryClient = new LiveQueryClient({
+      applicationId: 'applicationId',
+      serverURL: 'ws://test',
+      javascriptKey: 'javascriptKey',
+      masterKey: 'masterKey',
+      sessionToken: 'sessionToken',
+    });
+    liveQueryClient.socket = {
+      send: jest.fn(),
+    };
+    const query = new ParseQuery('Test');
+    query.equalTo('key', 'value');
+
+    const subscription = liveQueryClient.subscribe(query);
+    liveQueryClient.connectPromise.reject(new Error('Unable to connect'));
+    liveQueryClient.connectPromise.catch(() => {});
+    try {
+      await subscription.subscribePromise;
+      expect(true).toBeFalse();
+    } catch (e) {
+      expect(e.message).toBe('Unable to connect');
+    }
+  });
+
   it('can resubscribe', async () => {
     const liveQueryClient = new LiveQueryClient({
       applicationId: 'applicationId',

src/__tests__/ObjectStateMutations-test.js

@@ -199,6 +199,17 @@ describe('ObjectStateMutations', () => {
     expect(objectCache).toEqual({ data: '{"count":5}' });
   });
 
+  it('can commit nested changes from the server', () => {
+    const serverData = {};
+    const objectCache = {};
+    ObjectStateMutations.commitServerChanges(serverData, objectCache, {
+      'name.foo': 'bar',
+      data: { count: 5 },
+    });
+    expect(serverData).toEqual({ name: { foo: 'bar' }, data: { count: 5 }  });
+    expect(objectCache).toEqual({ data: '{"count":5}' });
+  });
+
   it('can generate a default state for implementations', () => {
     expect(ObjectStateMutations.defaultState()).toEqual({
       serverData: {},

src/__tests__/OfflineQuery-test.js

@@ -848,6 +848,33 @@ describe('OfflineQuery', () => {
     expect(matchesQuery(q.className, obj3, [], q)).toBe(false);
   });
 
+  it('should not support invalid $geoWithin query', () => {
+    const sacramento = new ParseObject('Location');
+    sacramento.set('location', new ParseGeoPoint(38.52, -121.5));
+    sacramento.set('name', 'Sacramento');
+
+    const honolulu = new ParseObject('Location');
+    honolulu.set('location', new ParseGeoPoint(21.35, -157.93));
+    honolulu.set('name', 'Honolulu');
+
+    const sf = new ParseObject('Location');
+    sf.set('location', new ParseGeoPoint(37.75, -122.68));
+    sf.set('name', 'San Francisco');
+
+    const points = [
+      new ParseGeoPoint(37.85, -122.33),
+      new ParseGeoPoint(37.85, -122.9),
+      new ParseGeoPoint(37.68, -122.9),
+      new ParseGeoPoint(37.68, -122.33),
+    ];
+    const q = new ParseQuery('Location');
+    q._addCondition('location', '$geoWithin', { $unknown: points });
+
+    expect(matchesQuery(q.className, sacramento, [], q)).toBe(false);
+    expect(matchesQuery(q.className, honolulu, [], q)).toBe(false);
+    expect(matchesQuery(q.className, sf, [], q)).toBe(false);
+  });
+
   it('should validate query', () => {
     let query = new ParseQuery('TestObject');
     query.equalTo('foo', 'bar');

src/__tests__/ParseObject-test.js

@@ -2302,13 +2302,14 @@ describe('ParseObject', () => {
     });
     const p = new ParseObject('Person');
     p.id = 'pid';
-    const result = p.destroy().then(() => {
+    const result = p.destroy({ sessionToken: 't_1234' }).then(() => {
       expect(xhr.open.mock.calls[0]).toEqual([
         'POST',
         'https://api.parse.com/1/classes/Person/pid',
         true,
       ]);
       expect(JSON.parse(xhr.send.mock.calls[0])._method).toBe('DELETE');
+      expect(JSON.parse(xhr.send.mock.calls[0])._SessionToken).toBe('t_1234');
     });
     jest.runAllTicks();
     await flushPromises();

src/__tests__/ParseUser-test.js

@@ -832,7 +832,7 @@ describe('ParseUser', () => {
       });
   });
 
-  it('removes the current user from disk when destroyed', done => {
+  it('removes the current user from disk when destroyed', async () => {
     ParseUser.enableUnsafeCurrentUser();
     ParseUser._clearCache();
     Storage._clear();
@@ -848,25 +848,21 @@ describe('ParseUser', () => {
       ajax() {},
     });
 
-    ParseUser.signUp('destroyed', 'password')
-      .then(u => {
-        expect(u.isCurrent()).toBe(true);
-        CoreManager.setRESTController({
-          request() {
-            return Promise.resolve({}, 200);
-          },
-          ajax() {},
-        });
-        return u.destroy();
-      })
-      .then(() => {
-        expect(ParseUser.current()).toBe(null);
-        return ParseUser.currentAsync();
-      })
-      .then(current => {
-        expect(current).toBe(null);
-        done();
-      });
+    const u = await ParseUser.signUp('destroyed', 'password');
+    expect(u.isCurrent()).toBe(true);
+    CoreManager.setRESTController({
+      request() {
+        return Promise.resolve({}, 200);
+      },
+      ajax() {},
+    });
+    await u.destroy();
+
+    expect(ParseUser.current()).toBe(null);
+    const current = await ParseUser.currentAsync();
+
+    expect(current).toBe(null);
+    await u.destroy();
   });
 
   it('updates the current user on disk when fetched', done => {
@@ -1531,6 +1527,7 @@ describe('ParseUser', () => {
 
     user.set('authData', { customAuth: true });
     expect(user._isLinked(provider)).toBe(true);
+    expect(user._isLinked('customAuth')).toBe(true);
 
     user.set('authData', 1234);
     expect(user._isLinked(provider)).toBe(false);