Merge branch 'issue-46'

Author: cmlccie

ciscosparkapi/exceptions.py

@@ -12,12 +12,11 @@
 from builtins import *
 from past.builtins import basestring
 
-import json
+import sys
+import textwrap
 
 import requests
 
-from collections import OrderedDict
-
 from ciscosparkapi.responsecodes import SPARK_RESPONSE_CODES
 
 
@@ -27,41 +26,90 @@
 __license__ = "MIT"
 
 
-class ciscosparkapiException(Exception):
-    """Base class for all ciscosparkapi package exceptions."""
+# Helper functions
+def sanitize(header_tuple):
+    """Sanitize request headers.
 
-    def __init__(self, *error_message_args, **error_data):
-        super(ciscosparkapiException, self).__init__()
-
-        self.error_message_args = error_message_args
-        self.error_data = OrderedDict(error_data)
-
-    @property
-    def error_message(self):
-        """The error message created from the error message arguments."""
-        if not self.error_message_args:
-            return ""
-        elif len(self.error_message_args) == 1:
-            return str(self.error_message_args[0])
-        elif len(self.error_message_args) > 1 \
-                and isinstance(self.error_message_args[0], basestring):
-            return self.error_message_args[0] % self.error_message_args[1:]
-        else:
-            return "; ".join(self.error_message_args)
+    Remove Spark authentication token.
+
+    """
+    header, value = header_tuple
+
+    if (header.lower().strip() == "Authorization".lower().strip()
+            and "Bearer".lower().strip() in value.lower().strip()):
+        return header, "Bearer <omitted>"
 
-    def __repr__(self):
-        """String representation of the exception."""
-        arg_list = self.error_message_args
-        kwarg_list = [str(key) + "=" + repr(value)
-                      for key, value in self.error_data.items()]
-        arg_string = ", ".join(arg_list + kwarg_list)
+    else:
+        return header_tuple
 
-        return self.__class__.__name__ + "(" + arg_string + ")"
 
-    def __str__(self):
-        """Human readable string representation of the exception."""
-        return self.error_message + '\n' + \
-            json.dumps(self.error_data, indent=4)
+def to_unicode(string):
+    """Convert a string (bytes, str or unicode) to unicode."""
+    assert isinstance(string, basestring)
+    if sys.version_info[0] >= 3:
+        if isinstance(string, bytes):
+            return string.decode('utf-8')
+        else:
+            return string
+    else:
+        if isinstance(string, str):
+            return string.decode('utf-8')
+        else:
+            return string
+
+
+def response_to_string(response):
+    """Render a response object as a human readable string."""
+    assert isinstance(response, requests.Response)
+    request = response.request
+
+    section_header = "{title:-^79}"
+
+    # Prepare request components
+    req = textwrap.fill("{} {}".format(request.method, request.url),
+                        width=79,
+                        subsequent_indent=' ' * (len(request.method)+1))
+    req_headers = [
+        textwrap.fill("{}: {}".format(*sanitize(header)),
+                      width=79,
+                      subsequent_indent=' '*4)
+        for header in request.headers.items()
+    ]
+    req_body = (textwrap.fill(to_unicode(request.body), width=79)
+                if request.body else "")
+
+    # Prepare response components
+    resp = textwrap.fill("{} {}".format(response.status_code,
+                                        response.reason
+                                        if response.reason else ""),
+                         width=79,
+                         subsequent_indent=' ' * (len(request.method)+1))
+    resp_headers = [
+        textwrap.fill("{}: {}".format(*header), width=79,
+                      subsequent_indent=' '*4)
+        for header in response.headers.items()
+    ]
+    resp_body = textwrap.fill(response.text, width=79) if response.text else ""
+
+    # Return the combined string
+    return "\n".join([
+        section_header.format(title="Request"),
+        req,
+        "\n".join(req_headers),
+        "",
+        req_body,
+        "",
+        section_header.format(title="Response"),
+        resp,
+        "\n".join(resp_headers),
+        "",
+        resp_body,
+    ])
+
+
+class ciscosparkapiException(Exception):
+    """Base class for all ciscosparkapi package exceptions."""
+    pass
 
 
 class SparkApiError(ciscosparkapiException):
@@ -70,47 +118,22 @@ class SparkApiError(ciscosparkapiException):
     def __init__(self, response):
         assert isinstance(response, requests.Response)
 
-        super(SparkApiError, self).__init__()
-
-        # Convenience data attributes
-        self.request = response.request
+        # Extended exception data attributes
         self.response = response
-        self.response_code = response.status_code
-        self.response_text = SPARK_RESPONSE_CODES.get(self.response_code,
-                                                      "Unknown Response Code")
-
-        # Error message and parameters
-        self.error_message_args = [
-            "Response Code [%s] - %s",
-            self.response_code,
-            self.response_text
-        ]
-
-        # Error Data
-        self.error_data["response_code"] = self.response_code
-        self.error_data["description"] = self.response_text
-        if response.text:
-            try:
-                response_data = json.loads(response.text,
-                                           object_pairs_hook=OrderedDict)
-            except ValueError:
-                self.error_data["response_body"] = response.text
-            else:
-                self.error_data["response_body"] = response_data
-
-
-class SparkRateLimitError(SparkApiError):
-    """Cisco Spark Rate-Limit exceeded Error."""
+        self.request = response.request
 
-    def __init__(self, response):
-        assert isinstance(response, requests.Response)
+        # Error message
+        response_code = response.status_code
+        description = SPARK_RESPONSE_CODES.get(response_code,
+                                               "Unknown Response Code")
+        detail = response_to_string(response)
 
-        super(SparkRateLimitError, self).__init__(response)
+        super(SparkApiError, self).__init__("Response Code [{}] - {}\n{}"
+                                            "".format(response_code,
+                                                      description,
+                                                      detail))
 
-        retry_after = response.headers.get('Retry-After')
-        if retry_after:
-            # Convenience data attributes
-            self.retry_after = float(retry_after)
 
-            # Error Data
-            self.error_data["retry_after"] = self.retry_after
+class SparkRateLimitError(SparkApiError):
+    """Cisco Spark Rate-Limit exceeded Error."""
+    pass

ciscosparkapi/utils.py

@@ -15,6 +15,7 @@
 import functools
 import mimetypes
 import os
+import sys
 import urllib.parse
 
 from collections import namedtuple
@@ -37,6 +38,36 @@
                            ['file_name', 'file_object', 'content_type'])
 
 
+def to_unicode(string):
+    """Convert a string (bytes, str or unicode) to unicode."""
+    assert isinstance(string, basestring)
+    if sys.version_info[0] >= 3:
+        if isinstance(string, bytes):
+            return string.decode('utf-8')
+        else:
+            return string
+    else:
+        if isinstance(string, str):
+            return string.decode('utf-8')
+        else:
+            return string
+
+
+def to_bytes(string):
+    """Convert a string (bytes, str or unicode) to bytes."""
+    assert isinstance(string, basestring)
+    if sys.version_info[0] >= 3:
+        if isinstance(string, str):
+            return string.encode('utf-8')
+        else:
+            return string
+    else:
+        if isinstance(string, unicode):
+            return string.encode('utf-8')
+        else:
+            return string
+
+
 def validate_base_url(base_url):
     """Verify that base_url specifies a protocol and network location."""
     parsed_url = urllib.parse.urlparse(base_url)