Endpoints for audiences CRUD

spec/AudienceRouter.spec.js

@@ -0,0 +1,287 @@
+var auth = require('../src/Auth');
+var Config = require('../src/Config');
+var rest = require('../src/rest');
+var AudiencesRouter = require('../src/Routers/AudiencesRouter').AudiencesRouter;
+
+describe('AudiencesRouter', () => {
+  it('uses find condition from request.body', (done) => {
+    var config = new Config('test');
+    var androidAudienceRequest = {
+      'name': 'Android Users',
+      'query': '{ "test": "android" }'
+    };
+    var iosAudienceRequest = {
+      'name': 'Iphone Users',
+      'query': '{ "test": "ios" }'
+    };
+    var request = {
+      config: config,
+      auth: auth.master(config),
+      body: {
+        where: {
+          query: '{ "test": "android" }'
+        }
+      },
+      query: {},
+      info: {}
+    };
+
+    var router = new AudiencesRouter();
+    rest.create(config, auth.nobody(config), '_Audience', androidAudienceRequest)
+      .then(() => {
+        return rest.create(config, auth.nobody(config), '_Audience', iosAudienceRequest);
+      })
+      .then(() => {
+        return router.handleFind(request);
+      })
+      .then((res) => {
+        var results = res.response.results;
+        expect(results.length).toEqual(1);
+        done();
+      })
+      .catch((err) => {
+        fail(JSON.stringify(err));
+        done();
+      });
+  });
+
+  it('uses find condition from request.query', (done) => {
+    var config = new Config('test');
+    var androidAudienceRequest = {
+      'name': 'Android Users',
+      'query': '{ "test": "android" }'
+    };
+    var iosAudienceRequest = {
+      'name': 'Iphone Users',
+      'query': '{ "test": "ios" }'
+    };
+    var request = {
+      config: config,
+      auth: auth.master(config),
+      body: {},
+      query: {
+        where: {
+          'query': '{ "test": "android" }'
+        }
+      },
+      info: {}
+    };
+
+    var router = new AudiencesRouter();
+    rest.create(config, auth.nobody(config), '_Audience', androidAudienceRequest)
+      .then(() => {
+        return rest.create(config, auth.nobody(config), '_Audience', iosAudienceRequest);
+      })
+      .then(() => {
+        return router.handleFind(request);
+      })
+      .then((res) => {
+        var results = res.response.results;
+        expect(results.length).toEqual(1);
+        done();
+      })
+      .catch((err) => {
+        fail(err);
+        done();
+      });
+  });
+
+  it('query installations with limit = 0', (done) => {
+    var config = new Config('test');
+    var androidAudienceRequest = {
+      'name': 'Android Users',
+      'query': '{ "test": "android" }'
+    };
+    var iosAudienceRequest = {
+      'name': 'Iphone Users',
+      'query': '{ "test": "ios" }'
+    };
+    var request = {
+      config: config,
+      auth: auth.master(config),
+      body: {},
+      query: {
+        limit: 0
+      },
+      info: {}
+    };
+
+    new Config('test');
+    var router = new AudiencesRouter();
+    rest.create(config, auth.nobody(config), '_Audience', androidAudienceRequest)
+      .then(() => {
+        return rest.create(config, auth.nobody(config), '_Audience', iosAudienceRequest);
+      })
+      .then(() => {
+        return router.handleFind(request);
+      })
+      .then((res) => {
+        var response = res.response;
+        expect(response.results.length).toEqual(0);
+        done();
+      })
+      .catch((err) => {
+        fail(JSON.stringify(err));
+        done();
+      });
+  });
+
+  it('query installations with count = 1', done => {
+    var config = new Config('test');
+    var androidAudienceRequest = {
+      'name': 'Android Users',
+      'query': '{ "test": "android" }'
+    };
+    var iosAudienceRequest = {
+      'name': 'Iphone Users',
+      'query': '{ "test": "ios" }'
+    };
+    var request = {
+      config: config,
+      auth: auth.master(config),
+      body: {},
+      query: {
+        count: 1
+      },
+      info: {}
+    };
+
+    var router = new AudiencesRouter();
+    rest.create(config, auth.nobody(config), '_Audience', androidAudienceRequest)
+      .then(() => rest.create(config, auth.nobody(config), '_Audience', iosAudienceRequest))
+      .then(() => router.handleFind(request))
+      .then((res) => {
+        var response = res.response;
+        expect(response.results.length).toEqual(2);
+        expect(response.count).toEqual(2);
+        done();
+      })
+      .catch(error => {
+        fail(JSON.stringify(error));
+        done();
+      })
+  });
+
+  it('query installations with limit = 0 and count = 1', (done) => {
+    var config = new Config('test');
+    var androidAudienceRequest = {
+      'name': 'Android Users',
+      'query': '{ "test": "android" }'
+    };
+    var iosAudienceRequest = {
+      'name': 'Iphone Users',
+      'query': '{ "test": "ios" }'
+    };
+    var request = {
+      config: config,
+      auth: auth.master(config),
+      body: {},
+      query: {
+        limit: 0,
+        count: 1
+      },
+      info: {}
+    };
+
+    var router = new AudiencesRouter();
+    rest.create(config, auth.nobody(config), '_Audience', androidAudienceRequest)
+      .then(() => {
+        return rest.create(config, auth.nobody(config), '_Audience', iosAudienceRequest);
+      })
+      .then(() => {
+        return router.handleFind(request);
+      })
+      .then((res) => {
+        var response = res.response;
+        expect(response.results.length).toEqual(0);
+        expect(response.count).toEqual(2);
+        done();
+      })
+      .catch((err) => {
+        fail(JSON.stringify(err));
+        done();
+      });
+  });
+
+  it('should create, read, update and delete audiences throw api', (done) => {
+    Parse._request('POST', 'push_audiences', { name: 'My Audience', query: JSON.stringify({ deviceType: 'ios' })}, { useMasterKey: true })
+      .then(() => {
+        Parse._request('GET', 'push_audiences', {}, { useMasterKey: true }).then((results) => {
+          expect(results.results.length).toEqual(1);
+          expect(results.results[0].name).toEqual('My Audience');
+          expect(results.results[0].query.deviceType).toEqual('ios');
+          Parse._request('GET', `push_audiences/${results.results[0].objectId}`, {}, { useMasterKey: true }).then((results) => {
+            expect(results.name).toEqual('My Audience');
+            expect(results.query.deviceType).toEqual('ios');
+            Parse._request('PUT', `push_audiences/${results.objectId}`, { name: 'My Audience 2' }, { useMasterKey: true }).then(() => {
+              Parse._request('GET', `push_audiences/${results.objectId}`, {}, { useMasterKey: true }).then((results) => {
+                expect(results.name).toEqual('My Audience 2');
+                expect(results.query.deviceType).toEqual('ios');
+                Parse._request('DELETE', `push_audiences/${results.objectId}`, {}, { useMasterKey: true }).then(() => {
+                  Parse._request('GET', 'push_audiences', {}, { useMasterKey: true }).then((results) => {
+                    expect(results.results.length).toEqual(0);
+                    done();
+                  });
+                });
+              });
+            });
+          });
+        });
+      });
+  });
+
+  it('should only create with master key', (done) => {
+    Parse._request('POST', 'push_audiences', { name: 'My Audience', query: JSON.stringify({ deviceType: 'ios' })})
+      .then(
+        () => {},
+        (error) => {
+          expect(error.message).toEqual('unauthorized: master key is required');
+          done();
+        }
+      );
+  });
+
+  it('should only find with master key', (done) => {
+    Parse._request('GET', 'push_audiences', {})
+      .then(
+        () => {},
+        (error) => {
+          expect(error.message).toEqual('unauthorized: master key is required');
+          done();
+        }
+      );
+  });
+
+  it('should only get with master key', (done) => {
+    Parse._request('GET', `push_audiences/someId`, {})
+      .then(
+        () => {},
+        (error) => {
+          expect(error.message).toEqual('unauthorized: master key is required');
+          done();
+        }
+      );
+  });
+
+  it('should only update with master key', (done) => {
+    Parse._request('PUT', `push_audiences/someId`, { name: 'My Audience 2' })
+      .then(
+        () => {},
+        (error) => {
+          expect(error.message).toEqual('unauthorized: master key is required');
+          done();
+        }
+      );
+  });
+
+  it('should only delete with master key', (done) => {
+    Parse._request('DELETE', `push_audiences/someId`, {})
+      .then(
+        () => {},
+        (error) => {
+          expect(error.message).toEqual('unauthorized: master key is required');
+          done();
+        }
+      );
+  });
+});

spec/ParseQuery.spec.js

@@ -915,15 +915,15 @@ describe('Parse.Query testing', () => {
 
   it("order by descending number and string, with space", function(done) {
     var strings = ["a", "b", "c", "d"];
-    var makeBoxedNumber = function(num, i) {
-      return new BoxedNumber({ number: num, string: strings[i] });
+    var makeBoxedNumber = function (num, i) {
+      return new BoxedNumber({number: num, string: strings[i]});
     };
     Parse.Object.saveAll([3, 1, 3, 2].map(makeBoxedNumber)).then(
-      function() {
+      function () {
         var query = new Parse.Query(BoxedNumber);
         query.descending("number, string");
         query.find(expectSuccess({
-          success: function(results) {
+          success: function (results) {
             equal(results.length, 4);
             equal(results[0].get("number"), 3);
             equal(results[0].get("string"), "c");
@@ -936,7 +936,8 @@ describe('Parse.Query testing', () => {
             done();
           }
         }));
-      }, (err) => {
+      },
+      (err) => {
         jfail(err);
         done();
       });

spec/RestQuery.spec.js

@@ -175,28 +175,28 @@ describe('rest query', () => {
 
       const p0 = rp.get({
         headers: headers,
-        url: 'http://localhost:8378/1/classes/TestParameterEncode?'
-                         + querystring.stringify({
-            where: '{"foo":{"$ne": "baz"}}',
-            limit: 1
-          }).replace('=', '%3D'),
-      }).then(fail, (response) => {
-        const error = response.error;
-        var b = JSON.parse(error);
-        expect(b.code).toEqual(Parse.Error.INVALID_QUERY);
-      });
+        url: 'http://localhost:8378/1/classes/TestParameterEncode?' + querystring.stringify({
+          where: '{"foo":{"$ne": "baz"}}',
+          limit: 1
+        }).replace('=', '%3D'),
+      })
+        .then(fail, (response) => {
+          const error = response.error;
+          var b = JSON.parse(error);
+          expect(b.code).toEqual(Parse.Error.INVALID_QUERY);
+        });
 
       const p1 = rp.get({
         headers: headers,
-        url: 'http://localhost:8378/1/classes/TestParameterEncode?'
-                         + querystring.stringify({
-            limit: 1
-          }).replace('=', '%3D'),
-      }).then(fail, (response) => {
-        const error = response.error;
-        var b = JSON.parse(error);
-        expect(b.code).toEqual(Parse.Error.INVALID_QUERY);
-      });
+        url: 'http://localhost:8378/1/classes/TestParameterEncode?' + querystring.stringify({
+          limit: 1
+        }).replace('=', '%3D'),
+      })
+        .then(fail, (response) => {
+          const error = response.error;
+          var b = JSON.parse(error);
+          expect(b.code).toEqual(Parse.Error.INVALID_QUERY);
+        });
       return Promise.all([p0, p1]);
     }).then(done).catch((err) => {
       jfail(err);

src/Adapters/Storage/Postgres/PostgresStorageAdapter.js

@@ -667,11 +667,11 @@ export class PostgresStorageAdapter {
         const joins = results.reduce((list, schema) => {
           return list.concat(joinTablesForSchema(schema.schema));
         }, []);
-        const classes = ['_SCHEMA','_PushStatus','_JobStatus','_JobSchedule','_Hooks','_GlobalConfig', ...results.map(result => result.className), ...joins];
-        return this._client.tx(t=>t.batch(classes.map(className=>t.none('DROP TABLE IF EXISTS $<className:name>', { className }))));
+        const classes = ['_SCHEMA', '_PushStatus', '_JobStatus', '_JobSchedule', '_Hooks', '_GlobalConfig', '_Audience', ...results.map(result => result.className), ...joins];
+        return this._client.tx(t=>t.batch(classes.map(className=>t.none('DROP TABLE IF EXISTS $<className:name>', {className}))));
       }, error => {
         if (error.code === PostgresRelationDoesNotExistError) {
-        // No _SCHEMA collection. Don't delete anything.
+          // No _SCHEMA collection. Don't delete anything.
           return;
         } else {
           throw error;

src/Controllers/DatabaseController.js

@@ -690,11 +690,12 @@ DatabaseController.prototype.reduceRelationKeys = function(className, query) {
     return this.relatedIds(
       relatedTo.object.className,
       relatedTo.key,
-      relatedTo.object.objectId).then((ids) => {
-      delete query['$relatedTo'];
-      this.addInObjectIdsIds(ids, query);
-      return this.reduceRelationKeys(className, query);
-    });
+      relatedTo.object.objectId)
+      .then((ids) => {
+        delete query['$relatedTo'];
+        this.addInObjectIdsIds(ids, query);
+        return this.reduceRelationKeys(className, query);
+      });
   }
 };