Merge pull request #555 from dplewis/jobs-cloud

dplewis · web-flow · commit cd057a51e68b · 2018-03-10T15:53:40.000-06:00
Add Jobs Functions to Cloud
diff --git a/integration/cloud/main.js b/integration/cloud/main.js
@@ -0,0 +1,25 @@
+Parse.Cloud.define("bar", function(request, response) {
+  if (request.params.key2 === "value1") {
+    response.success('Foo');
+  } else {
+    response.error("bad stuff happened");
+  }
+});
+
+Parse.Cloud.job('CloudJob1', function(request, response) {
+  response.success({
+    status: 'cloud job completed'
+  });
+});
+
+Parse.Cloud.job('CloudJob2', function(request, response) {
+  setTimeout(function() {
+    response.success({
+      status: 'cloud job completed'
+    })
+  }, 3000);
+});
+
+Parse.Cloud.job('CloudJobFailing', function(request, response) {
+  response.error('cloud job failed');
+});
diff --git a/integration/server.js b/integration/server.js
@@ -8,7 +8,8 @@ var api = new ParseServer({
   databaseURI: 'mongodb://localhost:27017/integration',
   appId: 'integration',
   masterKey: 'notsosecret',
-  serverURL: 'http://localhost:1337/parse' // Don't forget to change to https if needed
+  serverURL: 'http://localhost:1337/parse', // Don't forget to change to https if needed
+  cloud: `${__dirname}/cloud/main.js`
 });
 
 // Serve the Parse API on the /parse URL prefix
diff --git a/integration/test/ParseCloudTest.js b/integration/test/ParseCloudTest.js
@@ -0,0 +1,126 @@
+'use strict';
+
+const assert = require('assert');
+const clear = require('./clear');
+const mocha = require('mocha');
+const Parse = require('../../node');
+
+describe('Parse Cloud', () => {
+  before((done) => {
+    Parse.initialize('integration', null, 'notsosecret');
+    Parse.CoreManager.set('SERVER_URL', 'http://localhost:1337/parse');
+    Parse.Storage._clear();
+    clear().then(() => { done() }, () => { done() });
+  });
+
+  it('run function', (done) => {
+    const params = { key1: 'value2', key2: 'value1' };
+    Parse.Cloud.run('bar', params).then((result) => {
+      assert.equal('Foo', result);
+      done();
+    });
+  });
+
+  it('run function with user', (done) => {
+    const params = { key1: 'value2', key2: 'value1' };
+    const user = new Parse.User();
+    user.setUsername('someuser');
+    user.setPassword('somepassword');
+    user.signUp().then(() => {
+      return Parse.Cloud.run('bar', params);
+    }).then((resp) => {
+      assert.equal('Foo', resp);
+      return user.destroy({ useMasterKey: true });
+    }).then(() => {
+      done();
+    });
+  });
+
+  it('run function failed', (done) => {
+    const params = { key1: 'value1', key2: 'value2' };
+    Parse.Cloud.run('bar', params).then(null).catch((error) => {
+      assert.equal(error.code, Parse.Error.SCRIPT_FAILED);
+      done();
+    });
+  });
+
+  it('run function name fail', (done) => {
+    const params = { key1: 'value1' };
+    Parse.Cloud.run('unknown_function', params).then(null).catch((error) => {
+      assert.equal(error.message, 'Invalid function: "unknown_function"');
+      done();
+    });
+  });
+
+  it('run function with geopoint params does not fail', (done) => {
+    const params = { key1: new Parse.GeoPoint(50, 50) };
+    Parse.Cloud.run('unknown_function', params).then(null).catch((error) => {
+      assert.equal(error.message, 'Invalid function: "unknown_function"');
+      done();
+    });
+  });
+
+  it('run function with object params fail', (done) => {
+    const object = new Parse.Object('TestClass');
+    const params = { key1: object };
+    try {
+      Parse.Cloud.run('bar', params);
+    } catch (e) {
+      assert.equal(e, 'Error: Parse Objects not allowed here');
+      done();
+    }
+  });
+
+  it('run job', (done) => {
+    const params = { startedBy: 'Monty Python' };
+    Parse.Cloud.startJob('CloudJob1', params).then((jobStatusId) => {
+      return Parse.Cloud.getJobStatus(jobStatusId);
+    }).then((jobStatus) => {
+      assert.equal(jobStatus.get('status'), 'succeeded');
+      assert.equal(jobStatus.get('params').startedBy, 'Monty Python');
+      done();
+    });
+  });
+
+  it('run long job', (done) => {
+    Parse.Cloud.startJob('CloudJob2').then((jobStatusId) => {
+      return Parse.Cloud.getJobStatus(jobStatusId);
+    }).then((jobStatus) => {
+      assert.equal(jobStatus.get('status'), 'running');
+      done();
+    });
+  });
+
+  it('run bad job', (done) => {
+    Parse.Cloud.startJob('bad_job').then(null).catch((error) => {
+      assert.equal(error.code, Parse.Error.SCRIPT_FAILED);
+      assert.equal(error.message, 'Invalid job.');
+      done();
+    });
+  });
+
+  it('run failing job', (done) => {
+    Parse.Cloud.startJob('CloudJobFailing').then((jobStatusId) => {
+      return Parse.Cloud.getJobStatus(jobStatusId);
+    }).then((jobStatus) => {
+      assert.equal(jobStatus.get('status'), 'failed');
+      assert.equal(jobStatus.get('message'), 'cloud job failed');
+      done();
+    });
+  });
+
+  it('get jobs data', (done) => {
+    Parse.Cloud.getJobsData().then((result) => {
+      assert.equal(result.in_use.length, 0);
+      assert.equal(result.jobs.length, 3);
+      done();
+    });
+  });
+
+  it('invalid job status id', (done) => {
+    Parse.Cloud.getJobStatus('not-a-real-id').then(null).catch((error) => {
+      assert.equal(error.message, 'Object not found.');
+      done();
+    });
+  });
+});
diff --git a/integration/test/ParseQueryAggregateTest.js b/integration/test/ParseQueryAggregateTest.js
@@ -63,7 +63,7 @@ describe('Parse Aggregate Query', () => {
       assert.equal(results[0], 10);
       assert.equal(results[1], 20);
       done();
-    }).catch(done.fail);
+    });
   });
 
   it('distinct equalTo query', (done) => {
diff --git a/src/Cloud.js b/src/Cloud.js
@@ -14,6 +14,7 @@ import decode from './decode';
 import encode from './encode';
 import ParseError from './ParseError';
 import ParsePromise from './ParsePromise';
+import ParseQuery from './ParseQuery';
 
 /**
  * Contains functions for calling and declaring
@@ -60,9 +61,69 @@ export function run(
     requestOptions.sessionToken = options.sessionToken;
   }
 
-  return (
-    CoreManager.getCloudController().run(name, data, requestOptions)._thenRunCallbacks(options)
-  );
+  return CoreManager.getCloudController().run(name, data, requestOptions)._thenRunCallbacks(options);
+}
+
+ /**
+  * Gets data for the current set of cloud jobs.
+  * @method getJobsData
+  * @name Parse.Cloud.getJobsData
+  * @param {Object} options A Backbone-style options object
+  * options.success, if set, should be a function to handle a successful
+  * call to a cloud function.  options.error should be a function that
+  * handles an error running the cloud function.  Both functions are
+  * optional.  Both functions take a single argument.
+  * @return {Parse.Promise} A promise that will be resolved with the result
+  * of the function.
+  */
+export function getJobsData(options: { [key: string]: mixed }): ParsePromise {
+  options = options || {};
+  const requestOptions = {
+    useMasterKey: true
+  };
+  return CoreManager.getCloudController().getJobsData(requestOptions)._thenRunCallbacks(options);
+}
+
+ /**
+  * Starts a given cloud job, which will process asynchronously.
+  * @method startJob
+  * @name Parse.Cloud.startJob
+  * @param {String} name The function name.
+  * @param {Object} data The parameters to send to the cloud function.
+  * @param {Object} options A Backbone-style options object
+  * options.success, if set, should be a function to handle a successful
+  * call to a cloud function.  options.error should be a function that
+  * handles an error running the cloud function.  Both functions are
+  * optional.  Both functions take a single argument.
+  * @return {Parse.Promise} A promise that will be resolved with the result
+  * of the function.
+  */
+export function startJob(
+  name: string,
+  data: mixed,
+  options: { [key: string]: mixed }
+): ParsePromise {
+  options = options || {};
+
+  if (typeof name !== 'string' || name.length === 0) {
+    throw new TypeError('Cloud job name must be a string.');
+  }
+  const requestOptions = {
+    useMasterKey: true
+  };
+  return CoreManager.getCloudController().startJob(name, data, requestOptions)._thenRunCallbacks(options);
+}
+
+ /**
+  * Gets job status by Id
+  * @method getJobStatus
+  * @name Parse.Cloud.getJobStatus
+  * @param {String} jobStatusId The Id of Job Status.
+  * @return {Parse.Object} Status of Job.
+  */
+export function getJobStatus(jobStatusId: string): ParsePromise {
+  var query = new ParseQuery('_JobStatus');
+  return query.get(jobStatusId, { useMasterKey: true });
 }
 
 var DefaultController = {
@@ -71,19 +132,11 @@ var DefaultController = {
 
     var payload = encode(data, true);
 
-    var requestOptions = {};
-    if (options.hasOwnProperty('useMasterKey')) {
-      requestOptions.useMasterKey = options.useMasterKey;
-    }
-    if (options.hasOwnProperty('sessionToken')) {
-      requestOptions.sessionToken = options.sessionToken;
-    }
-
     var request = RESTController.request(
       'POST',
       'functions/' + name,
       payload,
-      requestOptions
+      options
     );
 
     return request.then(function(res) {
@@ -97,7 +150,35 @@ var DefaultController = {
           'The server returned an invalid response.'
         )
       );
-    })._thenRunCallbacks(options);
+    });
+  },
+
+  getJobsData(options) {
+    var RESTController = CoreManager.getRESTController();
+
+    var request = RESTController.request(
+      'GET',
+      'cloud_code/jobs/data',
+      null,
+      options
+    );
+
+    return request;
+  },
+
+  startJob(name, data, options) {
+    var RESTController = CoreManager.getRESTController();
+
+    var payload = encode(data, true);
+
+    var request = RESTController.request(
+      'POST',
+      'jobs/' + name,
+      payload,
+      options,
+    );
+
+    return request;
   }
 };
 
diff --git a/src/CoreManager.js b/src/CoreManager.js
@@ -30,6 +30,8 @@ type AnalyticsController = {
 };
 type CloudController = {
   run: (name: string, data: mixed, options: { [key: string]: mixed }) => ParsePromise;
+  getJobsData: (options: { [key: string]: mixed }) => ParsePromise;
+  startJob: (name: string, data: mixed, options: { [key: string]: mixed }) => ParsePromise;
 };
 type ConfigController = {
   current: () => ParsePromise;
@@ -197,7 +199,7 @@ module.exports = {
   },
 
   setCloudController(controller: CloudController) {
-    requireMethods('CloudController', ['run'], controller);
+    requireMethods('CloudController', ['run', 'getJobsData', 'startJob'], controller);
     config['CloudController'] = controller;
   },
 
diff --git a/src/RESTController.js b/src/RESTController.js
@@ -100,6 +100,13 @@ const RESTController = {
           var response;
           try {
             response = JSON.parse(xhr.responseText);
+
+            if (typeof xhr.getResponseHeader === 'function') {
+              var jobStatusId = xhr.getResponseHeader('x-parse-job-status-id');
+              if (jobStatusId) {
+                response = jobStatusId;
+              }
+            }
           } catch (e) {
             promise.reject(e.toString());
           }
diff --git a/src/__tests__/Cloud-test.js b/src/__tests__/Cloud-test.js
diff --git a/src/__tests__/CoreManager-test.js b/src/__tests__/CoreManager-test.js
diff --git a/src/__tests__/RESTController-test.js b/src/__tests__/RESTController-test.js
