def test_valid_query_params_list(self):
params = {
"a2": "r b",
"b5": "=%3D",
"a3": ["a", "2 q"],
"c@": [""],
"c2": "",
"non_string": 5,
"blank_list_value_not_preserved": [],
OAUTH_PARAM_CONSUMER_KEY: "9djdj82h48djs9d2",
OAUTH_PARAM_TOKEN: "kkk9d7dh3k39sjv7",
OAUTH_PARAM_SIGNATURE_METHOD: "HMAC-SHA1",
OAUTH_PARAM_TIMESTAMP: ["137131201"],
OAUTH_PARAM_NONCE: "7d8f3e4a",
}
valid_params_list = [
(b("a2"), b("r%20b")),
(b("a3"), b("2%20q")),
(b("a3"), b("a")),
(b("b5"), b("%3D%253D")),
(b("c%40"), b("")),
(b("c2"), b("")),
(b("non_string"), b("5")),
(utf8_encode(OAUTH_PARAM_CONSUMER_KEY), b("9djdj82h48djs9d2")),
(utf8_encode(OAUTH_PARAM_NONCE), b("7d8f3e4a")),
(utf8_encode(OAUTH_PARAM_SIGNATURE_METHOD), b("HMAC-SHA1")),
(utf8_encode(OAUTH_PARAM_TIMESTAMP), b("137131201")),
(utf8_encode(OAUTH_PARAM_TOKEN), b("kkk9d7dh3k39sjv7")),
]
self.assertEqual(urlencode_sl(params), valid_params_list)
def __init__(self, identifier, shared_secret):
"""
OAuth Credentials.
:param identifier:
Identifier (old: key)
:param shared_secret:
Shared secret (old: secret)
"""
self._identifier = utf8_encode(identifier)
self._shared_secret = utf8_encode(shared_secret)
def test_ignores_body_params_if_content_type_is_not_urlencoded(self):
oauth_params = dict(
oauth_consumer_key=RFC_CLIENT_IDENTIFIER,
oauth_token=RFC_TOKEN_IDENTIFIER,
oauth_signature_method=SIGNATURE_METHOD_HMAC_SHA1,
oauth_timestamp=RFC_TIMESTAMP_3,
oauth_nonce=RFC_NONCE_3,
)
self.assertEqual(_OAuthClient._generate_signature(
HTTP_GET,
# I Know ^ is a GET request and we're specifying a body in this
# test. _generate_signature does not validate HTTP methods,
# but only generates signatures. This example must produce
# the same signature as in the RFC example, hence the test.
RFC_RESOURCE_FULL_URL,
params=None,
body=b("""
body {
font-family: "Lucida Grande", serif;
}
a:link {
text-decoration: none;
}
"""),
headers={
HEADER_CONTENT_TYPE: CONTENT_TYPE_TEXT_CSS,
},
oauth_consumer_secret=RFC_CLIENT_SECRET,
oauth_token_secret=RFC_TOKEN_SECRET,
oauth_params=oauth_params,
), utf8_encode(percent_decode(RFC_RESOURCE_REQUEST_SIGNATURE_ENCODED)))
def test_blank_list_value_not_preserved(self):
params = {
"blank_list_value_not_preserved": [],
OAUTH_PARAM_CONSUMER_KEY: "9djdj82h48djs9d2",
OAUTH_PARAM_TOKEN: "kkk9d7dh3k39sjv7",
OAUTH_PARAM_SIGNATURE_METHOD: "HMAC-SHA1",
OAUTH_PARAM_TIMESTAMP: ["137131201"],
OAUTH_PARAM_NONCE: "7d8f3e4a",
}
valid_params_list = [
(utf8_encode(OAUTH_PARAM_CONSUMER_KEY), b("9djdj82h48djs9d2")),
(utf8_encode(OAUTH_PARAM_NONCE), b("7d8f3e4a")),
(utf8_encode(OAUTH_PARAM_SIGNATURE_METHOD), b("HMAC-SHA1")),
(utf8_encode(OAUTH_PARAM_TIMESTAMP), b("137131201")),
(utf8_encode(OAUTH_PARAM_TOKEN), b("kkk9d7dh3k39sjv7")),
]
self.assertEqual(urlencode_sl(params), valid_params_list)
def test_does_not_encode_bytes_or_None_to_utf8(self):
self.assertEqual(text.utf8_encode(None), None)
self.assertEqual(text.utf8_encode(constants.UTF8_BYTES), constants.UTF8_BYTES)
self.assertTrue(builtins.is_bytes(text.utf8_encode(constants.UTF8_BYTES)))
self.assertEqual(text.utf8_encode(constants.LATIN1_BYTES), constants.LATIN1_BYTES)
self.assertTrue(builtins.is_bytes(text.utf8_encode(constants.LATIN1_BYTES)))
self.assertEqual(text.utf8_encode(constants.UTF8_BYTES2), constants.UTF8_BYTES2)
self.assertTrue(builtins.is_bytes(text.utf8_encode(constants.UTF8_BYTES2)))
def test_does_not_encode_bytes_or_None_to_utf8(self):
self.assertEqual(utf8_encode(None), None)
self.assertEqual(utf8_encode(utf8_bytes), utf8_bytes)
self.assertTrue(is_bytes(utf8_encode(utf8_bytes)))
self.assertEqual(utf8_encode(latin1_bytes), latin1_bytes)
self.assertTrue(is_bytes(utf8_encode(latin1_bytes)))
self.assertEqual(utf8_encode(utf8_bytes2), utf8_bytes2)
self.assertTrue(is_bytes(utf8_encode(utf8_bytes2)))
def percent_encode(value):
"""
Percent-encodes according to the OAuth spec.
Used in constructing the signature base string and the "Authorization"
header field::
percent_encode('c@') -> 'c%40'
:see: Percent Encoding (http://tools.ietf.org/html/rfc5849#section-3.6)
:param value:
Query string parameter value to escape. If the value is a Unicode
string, it will be encoded to UTF-8. A byte string is considered
exactly that, a byte string and will not be UTF-8 encoded—however, it
will be percent-encoded.
:returns:
Percent-encoded string.
"""
# Escapes '/' too
if not is_bytes(value):
value = utf8_encode(str(value))
return quote(value, safe="~").encode("ascii")
def test_generates_signature_including_urlencoded_body(self):
oauth_params = dict(
oauth_consumer_key=RFC_CLIENT_IDENTIFIER,
oauth_token=RFC_TOKEN_IDENTIFIER,
oauth_signature_method=SIGNATURE_METHOD_HMAC_SHA1,
oauth_timestamp=RFC_TIMESTAMP_3,
oauth_nonce=RFC_NONCE_3,
)
self.assertEqual(_OAuthClient._generate_signature(
HTTP_GET,
# I Know ^ is a GET request and we're specifying a body in this
# test. _generate_signature does not validate HTTP methods,
# but only generates signatures. This example must produce
# the same signature as in the RFC example, hence the test.
RFC_RESOURCE_URI,
params=None,
body=b("file=vacation.jpg&size=original&oauth_ignored=IGNORED"),
headers={
HEADER_CONTENT_TYPE: CONTENT_TYPE_FORM_URLENCODED,
},
oauth_consumer_secret=RFC_CLIENT_SECRET,
oauth_token_secret=RFC_TOKEN_SECRET,
oauth_params=oauth_params,
), utf8_encode(percent_decode(RFC_RESOURCE_REQUEST_SIGNATURE_ENCODED)))
def test_encodes_only_unicode_to_utf8(self):
self.assertEqual(text.utf8_encode(constants.UNICODE_STRING), constants.UTF8_BYTES)
self.assertTrue(builtins.is_bytes(text.utf8_encode(constants.UNICODE_STRING)))
self.assertEqual(text.utf8_encode(constants.UNICODE_STRING2), constants.UTF8_BYTES2)
self.assertTrue(builtins.is_bytes(text.utf8_encode(constants.UNICODE_STRING2)))
def _build_request(cls, method, url, params, body, headers,
oauth_params, realm, use_authorization_header):
"""
Builds a request based on the HTTP arguments and OAuth protocol
parameters.
:param method:
HTTP method.
:param url:
Request URL
:param params:
Additional query/payload parameters.
If a `body` argument to this function is specified,
the parameters are appended to the URL query string.
If a `body` is not specified and a method other than GET is used
the parameters will be added to the entity body.
:param body:
Entity body.
:param oauth_params:
Protocol-specific parameters.
:param realm:
OAuth authorization realm.
:param use_authorization_header:
``True`` if the Authorization HTTP header should be used;
``False`` otherwise.
:returns:
An instance of :class:`pyoauth.http.RequestAdapter`.
"""
# http://tools.ietf.org/html/rfc5849#section-3.6
if HEADER_AUTHORIZATION_CAPS in headers or \
HEADER_AUTHORIZATION in headers:
raise InvalidAuthorizationHeaderError(
"Authorization field is already present in headers: %r" % \
headers
)
if use_authorization_header:
headers[HEADER_AUTHORIZATION_CAPS] = \
generate_authorization_header(oauth_params, realm)
# Empty oauth params so that they are not included again below.
oauth_params = None
# OAuth requests can contain payloads.
if body or method == HTTP_GET:
# Append params to query string.
url = url_append_query(url_add_query(url, params), oauth_params)
if body and method == HTTP_GET:
raise InvalidHttpRequestError(
"HTTP method GET does not take an entity body"
)
if body and \
HEADER_CONTENT_LENGTH not in headers and \
HEADER_CONTENT_LENGTH_CAPS not in headers:
raise ValueError("You must set the `content-length` header.")
else:
if params or oauth_params:
# Append to payload and set content type.
body = utf8_encode(query_append(params, oauth_params))
headers[HEADER_CONTENT_TYPE] = CONTENT_TYPE_FORM_URLENCODED
headers[HEADER_CONTENT_LENGTH] = str(len(body)).encode("ascii")
else:
# Zero-length body.
body = SYMBOL_EMPTY_BYTES
headers[HEADER_CONTENT_LENGTH] = SYMBOL_ZERO
return RequestAdapter(method, url, body, headers)
def test_raises_error_when_invalid_type(self): self.assertRaises(TypeError, json_encode, utf8_encode(unicode_value)) self.assertRaises(TypeError, json_encode, x_byte)
def test_raises_error_when_invalid_type(self): self.assertRaises(TypeError, json.json_encode, text.utf8_encode(constants.UNICODE_VALUE)) self.assertRaises(TypeError, json.json_encode, constants.X_BYTE)
def test_encodes_only_unicode_to_utf8(self):
self.assertEqual(utf8_encode(unicode_string), utf8_bytes)
self.assertTrue(is_bytes(utf8_encode(unicode_string)))
self.assertEqual(utf8_encode(unicode_string2), utf8_bytes2)
self.assertTrue(is_bytes(utf8_encode(unicode_string2)))
