added binary tests, added complete binary support

Author: zeryx

adk/ADK.py

@@ -43,6 +43,18 @@ def load(self):
                 print("PIPE_INIT_COMPLETE")
                 sys.stdout.flush()
 
+    def apply(self, payload):
+        try:
+            if self.load_result:
+                apply_result = self.apply_func(payload, self.load_result)
+            else:
+                apply_result = self.apply_func(payload)
+            response_obj = self.format_response(apply_result)
+            return response_obj
+        except Exception as e:
+            response_obj = self.create_exception(e)
+            return response_obj
+
     def format_data(self, request):
         if request["content_type"] in ["text", "json"]:
             data = request["data"]
@@ -114,27 +126,15 @@ def create_exception(self, exception, loading_exception=False):
         return response
 
     def process_loop(self):
-        response_obj = ""
         for line in sys.stdin:
-            try:
-                request = json.loads(line)
-                formatted_input = self.format_data(request)
-                if self.load_result:
-                    apply_result = self.apply_func(formatted_input, self.load_result)
-                else:
-                    apply_result = self.apply_func(formatted_input)
-                response_obj = self.format_response(apply_result)
-            except Exception as e:
-                response_obj = self.create_exception(e)
-            finally:
-                self.write_to_pipe(response_obj)
+            request = json.loads(line)
+            formatted_input = self.format_data(request)
+            result = self.apply(formatted_input)
+            self.write_to_pipe(result)
 
     def process_local(self, local_payload, pprint):
-        if self.load_result:
-            apply_result = self.apply_func(local_payload, self.load_result)
-        else:
-            apply_result = self.apply_func(local_payload)
-        pprint(self.format_response(apply_result))
+        result = self.apply(local_payload)
+        self.write_to_pipe(result, pprint=pprint)
 
     def init(self, local_payload=None, pprint=print):
         self.load()

run_tests.py

@@ -1,6 +1,8 @@
 from tests.test_adk_remote import RemoteTest
 from tests.test_adk_local import LocalTest
 import unittest
-
+import os
 if __name__ == "__main__":
+    if os.getenv('ALGORITHMIA_API_KEY', None) == None:
+        raise Exception("api key not provided, please export your ALGORITHMIA_API_KEY environment variable.")
     unittest.main()

tests/adk_algorithms.py

@@ -1,10 +1,14 @@
 import Algorithmia
-
+import base64
 
 # -- Apply functions --- #
 def apply_basic(input):
     return "hello " + input
 
+def apply_binary(input):
+    if isinstance(input, bytes):
+        input = input.decode('utf8')
+    return bytes("hello " + input, encoding='utf8')
 
 def apply_input_or_context(input, globals=None):
     if isinstance(globals, dict):

tests/test_adk_local.py

@@ -77,7 +77,7 @@ def test_error_loading(self):
         input = "Algorithmia"
         expected_output = {'error':
                                {'message': 'This exception was thrown in loading',
-                                'error_type': 'AlgorithmError',
+                                'error_type': 'LoadingError',
                                 'stacktrace': ''
                                 }
                            }
@@ -87,6 +87,29 @@ def test_error_loading(self):
         actual_output["error"]["stacktrace"] = ''
         self.assertEqual(expected_output, actual_output)
 
+    def test_error_binary_data(self):
+        input = b"payload"
+        expected_output = {'error':
+                               {'message': 'can only concatenate str (not "bytes") to str',
+                                'error_type': 'AlgorithmError',
+                                'stacktrace': ''
+                                }
+                           }
+        actual_output = json.loads(self.execute_without_load(input, apply_basic))
+        actual_output["error"]["stacktrace"] = ''
+        self.assertEqual(expected_output, actual_output)
+
+    def test_binary_data(self):
+        input = b"payload"
+        expected_output = {'metadata':
+            {
+                'content_type': 'binary'
+            },
+            'result': "aGVsbG8gcGF5bG9hZA=="
+        }
+        actual_output = json.loads(self.execute_without_load(input, apply_binary))
+        self.assertEqual(expected_output, actual_output)
+
 
 def run_test():
     unittest.main()

tests/test_adk_remote.py

@@ -3,6 +3,7 @@
 import unittest
 import os
 from adk import ADK
+import base64
 from tests.adk_algorithms import *
 
 
@@ -123,7 +124,7 @@ def test_error_loading(self):
         input = {'content_type': 'json', 'data': 'Algorithmia'}
         expected_output = {'error':
                                {'message': 'This exception was thrown in loading',
-                                'error_type': 'AlgorithmError',
+                                'error_type': 'LoadingError',
                                 'stacktrace': ''
                                 }
                            }
@@ -134,6 +135,31 @@ def test_error_loading(self):
         actual_output["error"]["stacktrace"] = ''
         self.assertEqual(expected_output, actual_output)
 
+    def test_error_binary_data(self):
+        input = {"content_type": "binary", "data": "cGF5bG9hZA=="}
+        expected_output = {'error':
+                               {'message': 'can only concatenate str (not "bytes") to str',
+                                'error_type': 'AlgorithmError',
+                                'stacktrace': ''
+                                }
+                           }
+        input = [str(json.dumps(input))]
+        actual_output = self.execute_without_load(input, apply_basic)
+        actual_output["error"]["stacktrace"] = ''
+        self.assertEqual(expected_output, actual_output)
+
+    def test_binary_data(self):
+        input = {"content_type": "binary", "data": "cGF5bG9hZA=="}
+        expected_output = {'metadata':
+            {
+                'content_type': 'binary'
+            },
+            'result': "aGVsbG8gcGF5bG9hZA=="
+        }
+        input = [str(json.dumps(input))]
+        actual_output = self.execute_without_load(input, apply_binary)
+        self.assertEqual(expected_output, actual_output)
+
 
 def run_test():
     unittest.main()