def test_normalize_request_parameters_params_string(self):
# params is a string but data is a dict
self.request.params = urlencode({'a': 'b'})
self.request.data = {'foo': 'bar'}
normalized = \
HmacSha1Signature()._normalize_request_parameters(self.request)
self.assertEqual('a=b&foo=bar', normalized)
def test_hmacsha1_signature(self):
self.request.params = {'foo': 'bar'}
oauth_signature = HmacSha1Signature().sign(self.request,
self.hook.consumer_key,
self.hook.access_token)
self.assertIsNotNone(oauth_signature)
self.assertTrue(isinstance(oauth_signature, str))
def test_sign_utf8_encoded_string(self):
# in the event a string is already UTF-8
req_kwargs = {u'params': {u'foo': u'bar'}}
sig = HmacSha1Signature().sign(self.consumer_secret,
self.access_token_secret, u'GET',
self.url, self.oauth_params, req_kwargs)
self.assertEqual('cYzjVXCOk62KoYmJ+iCvcAcgfp8=', sig)
def __init__(self,
consumer_key,
consumer_secret,
access_token=None,
access_token_secret=None,
header_auth=False,
signature=None,
default_oauth_callback=None):
# consumer credentials
self.consumer_key = consumer_key
self.consumer_secret = consumer_secret
# access token credentials
self.access_token = access_token
self.access_token_secret = access_token_secret
self.header_auth = header_auth
self.signature = HmacSha1Signature()
# override the default signature object if available
if signature is not None:
self.signature = signature
# 'oauth_callback' is required only on request-token requests
self.oauth_callback = default_oauth_callback
def test_normalize_request_parameters_both_string(self):
# params and data both as a string
self.request.params = urlencode({'a': 'b'})
self.request.data = urlencode({'foo': 'bar'})
normalized = \
HmacSha1Signature()._normalize_request_parameters(self.request)
# this also demonstrates sorting
self.assertEqual('a=b&foo=bar', normalized)
def test_sign_with_data(self):
# in the event a string is already UTF-8
req_kwargs = {'data': {'foo': 'bar'}}
method = 'POST'
sig = HmacSha1Signature().sign(self.consumer_secret,
self.access_token_secret, method,
self.url, self.oauth_params, req_kwargs)
self.assertEqual('JzmJUmqjdNYBJsJWbtQKXnc0W8w=', sig)
def test_hmacsha1_signature(self):
oauth_signature = HmacSha1Signature().sign(self.consumer_secret,
self.access_token_secret,
self.method, self.url,
self.oauth_params,
self.req_kwargs)
self.assertIsNotNone(oauth_signature)
self.assertIsInstance(oauth_signature, str)
self.assertEqual(oauth_signature, 'cYzjVXCOk62KoYmJ+iCvcAcgfp8=')
def test_normalize_request_parameters_data_string(self):
# params is a dict but data is a string
self.request.params = {'a': 'b'}
self.request.data = urlencode({'foo': 'bar'})
self.request.headers = \
{'Content-Type': 'application/x-www-form-urlencoded'}
normalized = \
HmacSha1Signature()._normalize_request_parameters(self.request)
self.assertEqual('a=b&foo=bar', normalized)
def test_normalize_request_parameters_both_string(self):
# params and data both as a string
self.request.params = urlencode({'a': 'b'})
self.request.data = urlencode({'foo': 'bar'})
self.request.headers = \
{'Content-Type': 'application/x-www-form-urlencoded'}
normalized = \
HmacSha1Signature()._normalize_request_parameters(self.request)
# this also demonstrates sorting
self.assertEqual('a=b&foo=bar', normalized)
def test_normalize_request_parameters_data(self):
# data as a dict
req_kwargs = {'data': {'foo': 'bar'},
'headers': {'Content-Type': FORM_URLENCODED}}
normalized = HmacSha1Signature()\
._normalize_request_parameters(self.oauth_params, req_kwargs)
self.assertEqual('foo=bar', normalized)
# data as a dict with URL encodable chars
req_kwargs = {'data': {'foo+bar': 'baz'},
'headers': {'Content-Type': FORM_URLENCODED}}
normalized = HmacSha1Signature()\
._normalize_request_parameters({}, req_kwargs)
self.assertEqual('foo%2Bbar=baz', normalized)
self.assertNotIn('+', normalized)
normalized = HmacSha1Signature()\
._normalize_request_parameters(self.oauth_params, req_kwargs)
self.assertEqual('foo%2Bbar=baz', normalized)
self.assertNotIn('+', normalized)
def test_normalize_request_parameters_whitespace(self):
req_kwargs = {
'data': {
'foo': 'bar baz'
},
'headers': {
'Content-Type': FORM_URLENCODED
}
}
normalized = HmacSha1Signature()\
._normalize_request_parameters(self.oauth_params, req_kwargs)
self.assertEqual('foo=bar%20baz', normalized)
def test_normalize_request_parameters_params(self):
# params as a dict
normalized = HmacSha1Signature()\
._normalize_request_parameters(self.oauth_params, self.req_kwargs)
self.assertEqual('foo=bar', normalized)
# params as a dict with URL encodable chars
normalized = HmacSha1Signature()\
._normalize_request_parameters(self.oauth_params,
{'params': {'foo+bar': 'baz'}})
self.assertEqual('foo%2Bbar=baz', normalized)
self.assertNotIn('+', normalized)
# params and dict as dicts
req_kwargs = {'params': {'a': 'b'},
'data': {'foo': 'bar'},
'headers': {'Content-Type': FORM_URLENCODED}}
normalized = HmacSha1Signature()\
._normalize_request_parameters({}, req_kwargs)
self.assertEqual('a=b&foo=bar', normalized)
def test_normalize_request_parameters_data(self):
# data as a dict
self.request.data = {'foo': 'bar'}
normalized = \
HmacSha1Signature()._normalize_request_parameters(self.request)
self.assertEqual('foo=bar', normalized)
# data as a dict with URL encodable chars
self.request.params_and_data = {}
self.request.data = {'foo+bar': 'baz'}
normalized = \
HmacSha1Signature()._normalize_request_parameters(self.request)
self.assertEqual('foo%2Bbar=baz', normalized)
self.assertTrue('+' not in normalized)
# data as a string with URL encodable chars
self.request.data = urlencode({'foo+bar': 'baz'})
normalized = \
HmacSha1Signature()._normalize_request_parameters(self.request)
self.assertEqual('foo%2Bbar=baz', normalized)
self.assertTrue('+' not in normalized)
def test_normalize_request_parameters_params(self):
# params as a dict
self.request.params = {'foo': 'bar'}
normalized = \
HmacSha1Signature()._normalize_request_parameters(self.request)
self.assertEqual('foo=bar', normalized)
# params as a dict with URL encodable chars
self.request.params_and_data = {}
self.request.params = {'foo+bar': 'baz'}
normalized = \
HmacSha1Signature()._normalize_request_parameters(self.request)
self.assertEqual('foo%2Bbar=baz', normalized)
self.assertTrue('+' not in normalized)
# params as a string
self.request.params_and_data = {}
self.request.params = urlencode({'foo': 'bar'})
normalized = \
HmacSha1Signature()._normalize_request_parameters(self.request)
self.assertEqual('foo=bar', normalized)
# params as a string with URL encodable chars
self.request.params_and_data = {}
self.request.params = urlencode({'foo+bar': 'baz'})
normalized = \
HmacSha1Signature()._normalize_request_parameters(self.request)
self.assertEqual('foo%2Bbar=baz', normalized)
self.assertTrue('+' not in normalized)
# params and dict as dicts
self.request.params_and_data = {}
self.request.params = {'a': 'b'}
self.request.data = {'foo': 'bar'}
self.request.headers = \
{'Content-Type': 'application/x-www-form-urlencoded'}
normalized = \
HmacSha1Signature()._normalize_request_parameters(self.request)
self.assertEqual('a=b&foo=bar', normalized)
def test_normalize_request_parameters_data_not_alphanumeric(self):
# data is not alphanumeric (for example: Japanese)
try:
from urllib import unquote
except ImportError:
from urllib.parse import unquote
# unicode
req_kwargs = {u'params': {u'foo': u'こんにちは世界'}}
normalized = HmacSha1Signature()\
._normalize_request_parameters({}, req_kwargs)
key, value = normalized.split('=')
decoded_value = unquote(value)
self.assertEqual('こんにちは世界', unquote(decoded_value))
# str
req_kwargs = {'params': {'foo': 'こんにちは世界'}}
normalized = HmacSha1Signature()\
._normalize_request_parameters({}, req_kwargs)
key, value = normalized.split('=')
decoded_value = unquote(value)
self.assertEqual('こんにちは世界', unquote(decoded_value))
def __init__(self,
consumer_key,
consumer_secret,
access_token=None,
access_token_secret=None,
header_auth=False,
signature=None):
self.consumer = Consumer(consumer_key, consumer_secret)
# intitialize the token and then set it if possible
self.token = None
if not None in (access_token, access_token_secret):
self.token = Token(access_token, access_token_secret)
self.header_auth = header_auth
self.signature = HmacSha1Signature()
# override the default signature object if available
if signature is not None:
self.signature = signature
def __init__(self,
consumer_key,
consumer_secret,
access_token=None,
access_token_secret=None,
header_auth=False,
signature=None):
# consumer credentials
self.consumer_key = consumer_key
self.consumer_secret = consumer_secret
# access token credentials
self.access_token = access_token
self.access_token_secret = access_token_secret
self.header_auth = header_auth
self.signature = HmacSha1Signature()
# override the default signature object if available
if signature is not None:
self.signature = signature
def test_remove_query_string(self):
# can't sign the URL with the query string so
url = 'http://example.com/?foo=bar'
signable_url = HmacSha1Signature()._remove_qs(url)
self.assertEqual('http://example.com/', signable_url)
def test_utf8_encoded_string(self):
# in the event a string is already UTF-8
self.request.params = {u'foo': u'bar'}
self.request.url = u'http://example.com/'
HmacSha1Signature().sign(self.request, self.hook.consumer_key)
self.assertEqual({'foo': 'bar'}, self.request.params)
