Add Request representation

2 files changed, 155 insertions, 0 deletions

diff --git a/oauthlib/common.py b/oauthlib/common.py
new file mode 100644
index 0000000..32438d0
--- /dev/null
+++ b/oauthlib/common.py
@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import
+
+"""
+oauthlib.common
+~~~~~~~~~~~~~~
+
+This module provides data structures and utilities common
+to all implementations of OAuth.
+"""
+
+from urlparse import parse_qsl, urlparse
+
+
+def extract_params(raw):
+    """Extract parameters and return them as a list of 2-tuples.
+
+    Will successfully extract parameters from urlencoded query strings,
+    dicts, or lists of 2-tuples. Empty strings/dicts/lists will return an
+    empty list of parameters. Any other input will result in a return
+    value of None.
+    """
+    if isinstance(raw, basestring):
+        if len(raw) == 0:
+            params = []  # short-circuit, strict parsing chokes on blank
+        else:
+            try:
+                params = parse_qsl(raw, keep_blank_values=True, strict_parsing=True)
+            except ValueError:
+                params = None  # No parameters to see here, move along.
+    elif hasattr(raw, '__iter__'):
+        try:
+            dict(raw)
+        except ValueError:
+            params = None
+        except TypeError:
+            params = None
+        else:
+            params = list(raw.items() if isinstance(raw, dict) else raw)
+    else:
+        params = None
+
+    return params
+
+
+class Request(object):
+    """A malleable representation of a signable HTTP request.
+
+    Body argument may contain any data, but parameters will only be decoded if
+    they are one of:
+
+    * urlencoded query string
+    * dict
+    * list of 2-tuples
+
+    Anything else will be treated as raw body data to be passed through
+    unmolested.
+    """
+
+    def __init__(self, uri, http_method=u'GET', body=None, headers=None):
+        self.uri = uri
+        self.http_method = http_method
+        self.headers = headers or {}
+        self.body = extract_params(body or [])
+        if self.body == None:
+            self.body = body
+            self.body_has_params = False
+        elif self.body == []:
+            self.body_has_params = False
+        else:
+            self.body_has_params = True
+        self.oauth_params = []
+
+    @property
+    def uri_query(self):
+        return urlparse(self.uri).query
+
+    @property
+    def uri_query_params(self):
+        return parse_qsl(self.uri_query, keep_blank_values=True,
+                                  strict_parsing=True)
diff --git a/tests/test_common.py b/tests/test_common.py
new file mode 100644
index 0000000..309ce76
--- /dev/null
+++ b/tests/test_common.py
@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import
+from oauthlib.common import extract_params, Request
+from .unittest import TestCase
+
+
+class CommonTests(TestCase):
+    params_dict = {u'foo': u'bar', u'baz': u'123', }
+    params_twotuple = [(u'foo', u'bar'), (u'baz', u'123')]
+    params_formencoded = u'foo=bar&baz=123'
+    uri = u'http://www.someuri.com'
+
+    def test_extract_params_dict(self):
+        self.assertEqual(extract_params(self.params_dict), self.params_twotuple)
+
+    def test_extract_params_twotuple(self):
+        self.assertEqual(extract_params(self.params_twotuple), self.params_twotuple)
+
+    def test_extract_params_formencoded(self):
+        self.assertEqual(extract_params(self.params_formencoded), self.params_twotuple)
+
+    def test_extract_params_blank_string(self):
+        self.assertEqual(extract_params(''), [])
+
+    def test_extract_params_empty_list(self):
+        self.assertEqual(extract_params([]), [])
+
+    def test_extract_non_formencoded_string(self):
+        self.assertEqual(extract_params('not a formencoded string'), None)
+
+    def test_extract_invalid(self):
+        self.assertEqual(extract_params(object()), None)
+
+    def test_none_body(self):
+        r = Request(self.uri)
+        self.assertEqual(r.body, [])
+        self.assertEqual(r.body_has_params, False)
+
+    def test_empty_list_body(self):
+        r = Request(self.uri, body=[])
+        self.assertEqual(r.body, [])
+        self.assertEqual(r.body_has_params, False)
+
+    def test_empty_dict_body(self):
+        r = Request(self.uri, body={})
+        self.assertEqual(r.body, [])
+        self.assertEqual(r.body_has_params, False)
+
+    def test_empty_string_body(self):
+        r = Request(self.uri, body='')
+        self.assertEqual(r.body, [])
+        self.assertEqual(r.body_has_params, False)
+
+    def test_non_formencoded_string_body(self):
+        body = 'foo bar baz la la la!'
+        r = Request(self.uri, body=body)
+        self.assertEqual(r.body, body)
+        self.assertEqual(r.body_has_params, False)
+
+    def test_param_free_sequence_body(self):
+        body = [1, 1, 2, 3, 5, 8, 13]
+        r = Request(self.uri, body=body)
+        self.assertEqual(r.body, body)
+        self.assertEqual(r.body_has_params, False)
+
+    def test_list_body(self):
+        r = Request(self.uri, body=self.params_twotuple)
+        self.assertEqual(r.body, self.params_twotuple)
+        self.assertEqual(r.body_has_params, True)
+
+    def test_dict_body(self):
+        r = Request(self.uri, body=self.params_dict)
+        self.assertEqual(r.body, self.params_twotuple)
+        self.assertEqual(r.body_has_params, True)