nico преди 8 години
родител
ревизия
c9744ee0a2
променени са 6 файла, в които са добавени 212 реда и са изтрити 8 реда
  1. 1 0
      install/files/python_requirements.txt
  2. 8 8
      manual_testing.py
  3. 0 0
      neurons/uri/__init__.py
  4. 0 0
      neurons/uri/tests/__init__.py
  5. 52 0
      neurons/uri/tests/uri_test_brain.yml
  6. 151 0
      neurons/uri/uri.py

+ 1 - 0
install/files/python_requirements.txt

@@ -15,3 +15,4 @@ python-twitter==3.1
 flask==0.11.1
 Flask-Restful==0.3.5
 wikipedia==1.4.0
+requests==2.12.1

+ 8 - 8
manual_testing.py

@@ -1,22 +1,22 @@
 # coding: utf8
 import logging
 
-from core.ConfigurationManager.BrainLoader import BrainLoader
+from core import OrderAnalyser
+from core.ConfigurationManager import BrainLoader
 from core.ConfigurationManager.SettingLoader import SettingLoader
 
 logging.basicConfig()
 logger = logging.getLogger("kalliope")
 logger.setLevel(logging.DEBUG)
 
-# file_path = "core/Tests/brains/brain_test.yml"
-#
-# brainloader1 = BrainLoader.Instance(file_path=file_path)
-#
-# brainloader2 = BrainLoader.Instance(file_path=file_path)
+brain_to_test = "neurons/uri/tests/uri_test_brain.yml"
+bl = BrainLoader.Instance(file_path=brain_to_test)
 
-sl = SettingLoader.Instance(file_path="core/Tests/settings/settings_test.yml")
-print sl.yaml_config
+order = "test-get-url"
 
+oa = OrderAnalyser(order, brain=bl.brain)
+
+oa.start()
 
 
 

+ 0 - 0
neurons/uri/__init__.py


+ 0 - 0
neurons/uri/tests/__init__.py


+ 52 - 0
neurons/uri/tests/uri_test_brain.yml

@@ -0,0 +1,52 @@
+---
+  # post
+  - name: "test-get-url"
+    signals:
+      - order: "test-get-url"
+    neurons:
+      - uri:
+          url: "http://jsonplaceholder.typicode.com/posts/1"
+
+  # post
+  - name: "test-post-url"
+    signals:
+      - order: "test-post-url"
+    neurons:
+      - uri:
+          url: "http://jsonplaceholder.typicode.com/posts"
+          headers:
+            user-agent: 'my-app/0.0.1'
+          timeout: 12
+          method: POST
+          data: "{\"title\": \"foo\", \"body\": \"bar\", \"userId\": 1}"
+
+  # put
+  - name: "test-put-url"
+    signals:
+      - order: "test-put-url"
+    neurons:
+      - uri:
+          url: "http://jsonplaceholder.typicode.com/posts/1"
+          method: PUT
+          data: "{\"id\": 1,\"title\": \"foo\", \"body\": \"bar\", \"userId\": 1}"
+
+  # patch
+  - name: "test-patch-url"
+    signals:
+      - order: "test-patch-url"
+    neurons:
+      - uri:
+          url: "http://jsonplaceholder.typicode.com/posts/1"
+          method: PATCH
+          data: "{\"title\": \"foo\"}"
+
+  # delete
+  - name: "test-delete-url"
+    signals:
+      - order: "test-delete-url"
+    neurons:
+      - uri:
+          url: "http://jsonplaceholder.typicode.com/posts/1"
+          method: DELETE
+          say_template:
+            - "{% if status_code==200 %}delete complete{% else %}fail to delete{% endif %}"

+ 151 - 0
neurons/uri/uri.py

@@ -0,0 +1,151 @@
+import json
+import logging
+
+import requests
+
+from core.NeuronModule import NeuronModule, InvalidParameterException
+
+logging.basicConfig()
+logger = logging.getLogger("kalliope")
+
+
+class Uri(NeuronModule):
+
+    def __init__(self, **kwargs):
+        super(Uri, self).__init__(**kwargs)
+
+        # input variables
+        self.url = kwargs.get('url', None)
+        self.headers = kwargs.get('headers', None)
+        self.data = kwargs.get('data', None)
+        self.method = kwargs.get('method', "GET")
+        self.user = kwargs.get('user', None)
+        self.password = kwargs.get('password', None)
+        self.timeout = kwargs.get('timeout', None)
+
+        # processing parameters
+        self.parameters = None
+
+        # output variable
+        self.status_code = None
+        self.content = None
+        self.response_header = None
+
+        # this is a switch case option
+        switch_case = {
+            "GET": self.do_get,
+            "POST": self.do_post,
+            "DELETE": self.do_delete,
+            "PUT": self.do_put,
+            "HEAD": self.do_head,
+            "PATCH": self.do_patch,
+            "OPTIONS": self.do_options
+        }
+
+        # check parameters
+        if self._is_parameters_ok():
+            # we get parameters that will be passed to the requests lib
+            self.parameters = self.get_parameters()
+            # we call the right method depending of the method selected
+            switch_case[self.method]()
+
+            message = {
+                "status_code": self.status_code,
+                "content": self.content,
+                "response_header": self.response_header
+            }
+
+            self.say(message)
+
+
+
+    def do_get(self):
+        logger.debug("do_get method called")
+        r = requests.get(url=self.url, **self.parameters)
+        self.post_processing_request(r)
+
+    def do_post(self):
+        logger.debug("do_post method called")
+        r = requests.post(url=self.url, **self.parameters)
+        self.post_processing_request(r)
+
+    def do_delete(self):
+        logger.debug("do_delete method called")
+        r = requests.delete(url=self.url, **self.parameters)
+        self.post_processing_request(r)
+
+    def do_put(self):
+        logger.debug("do_put method called")
+        r = requests.put(url=self.url, **self.parameters)
+        self.post_processing_request(r)
+
+    def do_head(self):
+        logger.debug("do_head method called")
+        r = requests.head(url=self.url, **self.parameters)
+        self.post_processing_request(r)
+
+    def do_patch(self):
+        logger.debug("do_patch method called")
+        r = requests.patch(url=self.url, **self.parameters)
+        self.post_processing_request(r)
+
+    def do_options(self):
+        logger.debug("do_options method called")
+        r = requests.options(url=self.url, **self.parameters)
+        self.post_processing_request(r)
+
+    def get_parameters(self):
+        """
+
+        :return: Dict of parameters usable by the "requests" lib
+        """
+        logger.debug("get_parameters method called")
+        returned_parameters = dict()
+
+        if self.headers is not None:
+            returned_parameters["headers"] = self.headers
+
+        if self.timeout is not None:
+            returned_parameters["timeout"] = self.timeout
+
+        if self.data is not None:
+            returned_parameters["data"] = self.data
+
+        print returned_parameters
+
+        return returned_parameters
+
+    def post_processing_request(self, r):
+        self.status_code = r.status_code
+        self.content = r.content
+        self.response_header = r.headers
+
+        logger.debug("status_code: %s" % self.status_code)
+        logger.debug("content: %s" % self.content)
+        logger.debug("response_header: %s" % self.response_header)
+
+        return
+
+    def _is_parameters_ok(self):
+        if self.url is None:
+            raise InvalidParameterException("Uri needs an url")
+
+        if self.headers is not None:
+            if not isinstance(self.headers, dict):
+                raise InvalidParameterException("headers must be a list of string")
+
+        if self.timeout is not None:
+            if not isinstance(self.timeout, int):
+                raise InvalidParameterException("timeout must be an integer")
+
+        if self.data is not None:
+            try:
+                self.data = json.loads(self.data)
+            except ValueError, e:
+                raise InvalidParameterException("error in \"data\" parameter: %s" % e)
+
+        allowed_method = ["GET", "POST", "DELETE", "PUT", "HEAD", "PATCH", "OPTIONS"]
+        if self.method not in allowed_method:
+            raise InvalidParameterException("method %s not in: %s" % (self.method, allowed_method))
+
+        return True