pass all the tests! ....almost

fractalis/analytics/controllers.py

@@ -28,28 +28,31 @@ def permanent_session():
 @validate_json
 @validate_schema(create_job_schema)
 def create_job():
-    task = get_celery_task(request.json['task'])
+    json = request.get_json(force=True)
+    task = get_celery_task(json['task'])
     if task is None:
         return jsonify({'error': 'Task {} not found.'.format(
-            request.json['task'])}), 400
+            json['task'])}), 400
     try:
-        async_result = task.delay(*request.json['arguments'])
+        async_result = task.delay(*json['args'])
     except TypeError as e:
         return jsonify({'error': 'Invalid Arguments for task {}: {}'.format(
-                request.json['task'], e)}), 400
+                json['task'], e)}), 400
 
-    if 'jobs' not in session:
-        session['jobs'] = []
-    session['jobs'].append(async_result.id)
-    return jsonify({'job_id': async_result.id}), 201
+    if 'tasks' not in session:
+        session['tasks'] = []
+    session['tasks'].append(async_result.id)
+    return jsonify({'task_id': async_result.id}), 201
 
 
-@analytics_blueprint.route('/<uuid:job_id>', methods=['GET'])
-def get_job_details(job_id):
-    async_result = celery.AsyncResult(request.json['uuid'])
+@analytics_blueprint.route('/<uuid:task_id>', methods=['GET'])
+def get_job_details(task_id):
+    task_id = str(task_id)
+    async_result = celery.AsyncResult(task_id)
     return jsonify({'status': async_result.state}), 200
 
 
-@analytics_blueprint.route('/<uuid:job_id>', methods=['DELETE'])
-def cancel_job(job_id):
-    pass
+@analytics_blueprint.route('/<uuid:task_id>', methods=['DELETE'])
+def cancel_job(task_id):
+    task_id = str(task_id)
+    celery.control.revoke(task_id, terminate=True)

fractalis/analytics/schema.py

@@ -2,7 +2,7 @@ create_job_schema = {
     "type": "object",
     "properties": {
         "task": {"type": "string", "minLength": 5},
-        "arguments": {"type": "object", "minProperties": 1},
+        "args": {"type": "object", "minProperties": 1},
     },
-    "required": ["task", "arguments"]
+    "required": ["task", "args"]
 }

fractalis/validator.py

@@ -11,7 +11,8 @@ def validate_json(f):
     @wraps(f)
     def wrapper(*args, **kwargs):
         try:
-            if not (request.json):
+            json = request.get_json(force=True)
+            if not (json):
                 raise BadRequest()
         except BadRequest:
             error_msg = "Request payload must be valid JSON."
@@ -24,8 +25,9 @@ def validate_schema(schema):
     def decorator(f):
         @wraps(f)
         def wrapper(*args, **kwargs):
+            json = request.get_json(force=True)
             try:
-                validate(request.json, schema)
+                validate(json, schema)
             except ValidationError as e:
                 return jsonify({'error': e.message}), 400
             return f(*args, **kwargs)

tests/test_analytics.py

@@ -18,33 +18,31 @@ class TestAnalytics(object):
     def test_new_resource_created(self, app):
         rv = app.post('/analytics', data=flask.json.dumps(dict(
             task='test.add',
-            arguments={'a': 1, 'b': 1}
-        )), content_type='application/json')
+            args={'a': 1, 'b': 1}
+        )))
         body = flask.json.loads(rv.get_data())
-        new_url = '/analytics/{}'.format(body['job_id'])
+        new_url = '/analytics/{}'.format(body['task_id'])
         assert rv.status_code == 201
-        assert uuid.UUID(body['job_id'])
-        import pdb; pdb.set_trace()
+        assert uuid.UUID(body['task_id'])
         assert app.head(new_url).status_code == 200
 
     @pytest.fixture(scope='module',
                     params=[{'task': 'querty.add',
-                             'arguments': {'a': 1, 'b': 2}},
+                             'args': {'a': 1, 'b': 2}},
                             {'task': 'test.querty',
-                             'arguments': {'a': 1, 'b': 2}},
+                             'args': {'a': 1, 'b': 2}},
                             {'task': 'test.add',
-                             'arguments': {'a': 1, 'c': 2}},
+                             'args': {'a': 1, 'c': 2}},
                             {'task': 'test.add',
-                             'arguments': {'a': 1}},
+                             'args': {'a': 1}},
                             {'task': 'test.add'},
-                            {'arguments': {'a': 1, 'b': 2}},
+                            {'args': {'a': 1, 'b': 2}},
                             {'task': '',
-                             'arguments': {'a': 1, 'b': 2}},
+                             'args': {'a': 1, 'b': 2}},
                             {'task': 'querty.add',
-                             'arguments': ''}])
+                             'args': ''}])
     def bad_request(self, app, request):
-        return app.post('/analytics', data=flask.json.dumps(request.param),
-                        content_type='application/json')
+        return app.post('/analytics', data=flask.json.dumps(request.param))
 
     def test_400_if_POST_body_invalid(self, bad_request):
         assert bad_request.status_code == 400
@@ -52,15 +50,15 @@ class TestAnalytics(object):
     def test_403_if_creating_but_not_authenticated(self, app):
         assert False
 
-    # test DELETE to /analytics/{job_id}
+    # test DELETE to /analytics/{task_id}
 
     def test_resource_deleted(self, app):
-        rv = app.post('/analytics', data=dict(
+        rv = app.post('/analytics', data=flask.json.dumps(dict(
             task='test.add',
-            arguments={'a': 1, 'b': 1}
-        ))
+            args={'a': 1, 'b': 1}
+        )))
         body = flask.json.loads(rv.get_data())
-        new_url = '/analytics/{}'.format(body['job_id'])
+        new_url = '/analytics/{}'.format(body['task_id'])
         assert app.head(new_url).status_code == 200
         assert app.delete(new_url).status_code == 200
         assert app.head(new_url).status_code == 404
@@ -70,12 +68,12 @@ class TestAnalytics(object):
         assert rv.status_code == 404
 
     def test_running_resource_deleted(self, app):
-        rv = app.post('/analytics', data=dict(
+        rv = app.post('/analytics', data=flask.json.dumps(dict(
             task='test.do_nothing',
-            arguments={'time': 10}
-        ))
+            args={'time': 10}
+        )))
         body = flask.json.loads(rv.get_data())
-        new_url = '/analytics/{}'.format(body['job_id'])
+        new_url = '/analytics/{}'.format(body['task_id'])
         assert app.head(new_url).status_code == 200
         assert app.delete(new_url).status_code == 200
         assert app.head(new_url).status_code == 404
@@ -83,38 +81,38 @@ class TestAnalytics(object):
     def test_403_if_deleting_but_not_authenticated(self, app):
         assert False
 
-    # test GET to /analytics/{job_id}
+    # test GET to /analytics/{task_id}
 
     def test_status_contains_result_if_finished(self, app):
-        rv = app.post('/analytics', data=dict(
+        rv = app.post('/analytics', data=flask.json.dumps(dict(
             task='test.add',
-            arguments={'a': 1, 'b': 2}
-        ))
+            args={'a': 1, 'b': 2}
+        )))
         body = flask.json.loads(rv.get_data())
-        new_url = '/analytics/{}'.format(body['job_id'])
+        new_url = '/analytics/{}'.format(body['task_id'])
         new_response = app.get(new_url)
         new_body = flask.json.loads(new_response.get_data())
         assert new_body['result'] == 3
 
     def test_status_result_empty_if_not_finished(self, app):
-        rv = app.post('/analytics', data=dict(
+        rv = app.post('/analytics', data=flask.json.dumps(dict(
             task='test.do_nothing',
-            arguments={'time': 10}
-        ))
+            args={'time': 10}
+        )))
         body = flask.json.loads(rv.get_data())
-        new_url = '/analytics/{}'.format(body['job_id'])
+        new_url = '/analytics/{}'.format(body['task_id'])
         new_response = app.get(new_url)
         new_body = flask.json.loads(new_response.get_data())
         assert not new_body['result']
         assert new_body['status'] == 'RUNNING'
 
     def test_correct_response_if_task_fails(self, app):
-        rv = app.post('/analytics', data=dict(
+        rv = app.post('/analytics', data=flask.json.dumps(dict(
             task='test.div',
-            arguments={}
-        ))
+            args={}
+        )))
         body = flask.json.loads(rv.get_data())
-        new_url = '/analytics/{}'.format(body['job_id'])
+        new_url = '/analytics/{}'.format(body['task_id'])
         new_response = app.get(new_url)
         new_body = flask.json.loads(new_response.get_data())
         assert new_body['status'] == 'FAILURE'