Merge pull request #206 from Syncano/LIB-656

opalczynski · opalczynski · commit cbb519fab18d · 2016-06-08T08:46:14.000+02:00
[LIB-656] add cache_key support for data endpoints and script endpoints;
diff --git a/syncano/models/archetypes.py b/syncano/models/archetypes.py
@@ -225,10 +225,11 @@ def to_python(self, data):
         :type data: dict
         :param data: Raw data
         """
+
         for field in self._meta.fields:
             field_name = field.name
 
-            if field.mapping is not None and self.pk:
+            if field.mapping is not None and not self.is_new():
                 field_name = field.mapping
 
             if field_name in data:
diff --git a/syncano/models/data_views.py b/syncano/models/data_views.py
@@ -28,7 +28,7 @@ class EndpointData(Model):
     name = fields.StringField(max_length=64, primary_key=True)
     description = fields.StringField(required=False)
 
-    query = fields.JSONField(read_only=False, required=True)
+    query = fields.JSONField(read_only=False, required=False)
 
     class_name = fields.StringField(label='class name', mapping='class')
 
@@ -78,12 +78,21 @@ def clear_cache(self):
         connection = self._get_connection()
         return connection.request('POST', endpoint)
 
-    def get(self):
+    def get(self, cache_key=None):
         properties = self.get_endpoint_data()
         endpoint = self._meta.resolve_endpoint('get', properties)
         connection = self._get_connection()
+
+        kwargs = {}
+        params = {}
+        if cache_key is not None:
+            params = {'cache_key': cache_key}
+
+        if params:
+            kwargs = {'params': params}
+
         while endpoint is not None:
-            response = connection.request('GET', endpoint)
+            response = connection.request('GET', endpoint, **kwargs)
             endpoint = response.get('next')
             for obj in response['objects']:
                 yield obj
diff --git a/syncano/models/incentives.py b/syncano/models/incentives.py
@@ -254,7 +254,7 @@ class Meta:
             }
         }
 
-    def run(self, **payload):
+    def run(self, cache_key=None, **payload):
         """
         Usage::
 
@@ -271,7 +271,15 @@ def run(self, **payload):
         endpoint = self._meta.resolve_endpoint('run', properties)
         connection = self._get_connection(**payload)
 
-        response = connection.request('POST', endpoint, **{'data': payload})
+        params = {}
+        if cache_key is not None:
+            params = {'cache_key': cache_key}
+
+        kwargs = {'data': payload}
+        if params:
+            kwargs.update({'params': params})
+
+        response = connection.request('POST', endpoint, **kwargs)
 
         if isinstance(response, dict) and 'result' in response and 'stdout' in response['result']:
             response.update({'instance_name': self.instance_name,
diff --git a/syncano/models/instances.py b/syncano/models/instances.py
@@ -51,6 +51,7 @@ class Instance(RenameMixin, Model):
     # snippets and data fields;
     scripts = fields.RelatedManagerField('Script')
     script_endpoints = fields.RelatedManagerField('ScriptEndpoint')
+    data_endpoints = fields.RelatedManagerField('EndpointData')
     templates = fields.RelatedManagerField('ResponseTemplate')
 
     triggers = fields.RelatedManagerField('Trigger')
diff --git a/tests/integration_test_cache.py b/tests/integration_test_cache.py
@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+from syncano.models import RuntimeChoices
+from tests.integration_test import InstanceMixin, IntegrationTest
+
+
+class DataEndpointCacheTest(InstanceMixin, IntegrationTest):
+
+    @classmethod
+    def setUpClass(cls):
+        super(DataEndpointCacheTest, cls).setUpClass()
+        cls.klass = cls.instance.classes.create(
+            name='sample_klass',
+            schema=[
+                {'name': 'test1', 'type': 'string'},
+                {'name': 'test2', 'type': 'string'}
+            ])
+
+        cls.data_object = cls.klass.objects.create(
+            class_name=cls.klass.name,
+            test1='123',
+            test2='321',
+        )
+
+        cls.data_endpoint = cls.instance.data_endpoints.create(
+            name='test_data_endpoint',
+            description='test description',
+            class_name=cls.klass.name
+        )
+
+    def test_cache_request(self):
+        data_endpoint = list(self.data_endpoint.get(cache_key='12345'))
+
+        self.assertTrue(data_endpoint)
+
+        for data_object in data_endpoint:
+            self.assertTrue(data_object)
+
+
+class ScriptEndpointCacheTest(InstanceMixin, IntegrationTest):
+
+    @classmethod
+    def setUpClass(cls):
+        super(ScriptEndpointCacheTest, cls).setUpClass()
+
+        cls.script = cls.instance.scripts.create(
+            label='test_script',
+            description='test script desc',
+            source='print(12)',
+            runtime_name=RuntimeChoices.PYTHON_V5_0,
+        )
+
+        cls.script_endpoint = cls.instance.script_endpoints.create(
+            name='test_script_endpoint',
+            script=cls.script.id
+        )
+
+    def test_cache_request(self):
+        response = self.script_endpoint.run(cache_key='123456')
+        self.assertEqual(response.result['stdout'], '12')
